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;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,mDAAmD,8BAA8B;AACjF,8CAA8C,8BAA8B;AAC5E,0EAA0E,MAAM,yBAAyB,kBAAkB,KAAK,kBAAkB,KAAK,eAAe;AACtK;AACA;AACA,2DAA2D,mCAAmC;AAC9F;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,kCAAkC;AAClC,6BAA6B;AAC7B;AACA;AACA;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB,YAAY,UAAU;AACtB,YAAY,UAAU;AACtB,YAAY,UAAU;AACtB;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,GAAG;;AAEH,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,aAAa;AACzB,YAAY,QAAQ;AACpB,aAAa,UAAU;AACvB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,mBAAmB,wBAAwB;;AAE3C;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,aAAa;AACzB;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,MAAM;;AAEN;AACA;;AAEA,MAAM;;AAEN;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,sBAAsB,YAAY;;AAElC;AACA;AACA;;AAEA;;AAEA;;AAEA,MAAM,OAAO;;AAEb,sBAAsB,YAAY;;AAElC;;AAEA;;AAEA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;AACA,sBAAsB,YAAY;;AAElC;AACA;;AAEA;AACA;;AAEA,MAAM,OAAO;;AAEb;AACA,sBAAsB,YAAY;;AAElC;;AAEA;;AAEA;;AAEA,KAAK;;AAEL;;AAEA;AACA,qBAAqB,QAAQ;;AAE7B;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,qBAAqB,2BAA2B;;AAEhD;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,YAAY,MAAM;AAClB;AACA;;AAEA;AACA;;AAEA;;AAEA,mBAAmB,WAAW;;AAE9B;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,SAAS;AACtB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,mBAAmB,cAAc;;AAEjC;;AAEA;;AAEA,WAAW;;AAEX,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,OAAO;AACpB;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;AACA;AACA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,YAAY,QAAQ;AACpB;AACA;;AAEA;;AAEA;;AAEA;;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mGAAmG;AACnG;AACA;AACA,mGAAmG;AACnG;AACA;AACA;AACA;AACA;AACA;AACA,mGAAmG;AACnG;AACA;AACA,mGAAmG;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;;ACxLA;AACA,qDAAqD,kGAAkG;AACvJ;;AAEsB;;;ACJtB,+CAAe;AACf,IAAI,iCAAiC,mGAAmG,6CAA6C,oBAAoB,0BAA0B,SAAS;;AAE5O,IAAI,iCAAiC,+EAA+E,4CAA4C,EAAE,6CAA6C,mBAAmB,0BAA0B,SAAS;;AAErQ,IAAI,2BAA2B,uQAAuQ,4DAA4D,EAAE,6DAA6D,EAAE,4DAA4D,EAAE,4DAA4D,EAAE,sDAAsD,EAAE,4DAA4D,EAAE,+DAA+D,EAAE,0DAA0D,EAAE,2DAA2D,EAAE,2DAA2D,0BAA0B,0BAA0B,SAAS;;AAEv8B,IAAI,kCAAkC,mGAAmG,+CAA+C,mBAAmB,2BAA2B,SAAS;;AAE/O,IAAI,oDAAoD,mDAAmD,wDAAwD,QAAQ,8CAA8C,EAAE,+CAA+C,mBAAmB,0BAA0B,SAAS;;AAEhU,IAAI,4CAA4C,mDAAmD,uDAAuD,EAAE,uDAAuD,EAAE,sDAAsD,EAAE,uDAAuD,QAAQ,6CAA6C,EAAE,6CAA6C,EAAE,6CAA6C,EAAE,6CAA6C,EAAE,6CAA6C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,2CAA2C,EAAE,6CAA6C,EAAE,6CAA6C,EAAE,8CAA8C,EAAE,8CAA8C,EAAE,8CAA8C,mBAAmB,2BAA2B,SAAS;;AAElhC,IAAI,uCAAuC,sIAAsI,4CAA4C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,8CAA8C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,8CAA8C,EAAE,8CAA8C,EAAE,4CAA4C,EAAE,+CAA+C,EAAE,4CAA4C,EAAE,4CAA4C,EAAE,8CAA8C,EAAE,4CAA4C,EAAE,+CAA+C,EAAE,4CAA4C,EAAE,6CAA6C,EAAE,8CAA8C,EAAE,6CAA6C,EAAE,4CAA4C,EAAE,8CAA8C,mBAAmB,yBAAyB,SAAS;;AAE9oD,IAAI,oCAAoC,kPAAkP,iDAAiD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,iDAAiD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,+CAA+C,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,EAAE,kDAAkD,oBAAoB,0BAA0B;AACjoC,CAAC,EAAC;;;AChByC;AACN;;AAErC,MAAM,iCAAiB;;AAER;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,oBAAoB,IAAI,QAAQ,SAAS;AACzC,yCAAyC,EAAE,qDAAqD,QAAQ;AACxG;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,gCAAgC,iCAAiB;;AAEjD;AACA;;AAEA;AACA,6DAA6D,iCAAiB;;AAE9E;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D;AAC9D;AACA;AACA;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;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,gBAAgB;AAClC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA,aAAa,uBAAuB;AACpC,oBAAoB,sDAAsD;AAC1E,2BAA2B,8EAA8E;AACzG,0BAA0B,0BAA0B;AACpD,2BAA2B,0BAA0B;AACrD,mBAAmB,cAAc;AACjC,oBAAoB,eAAe;AACnC,mBAAmB,cAAc;AACjC,oBAAoB,cAAc;AAClC,wBAAwB,cAAc;AACtC,0BAA0B,cAAc;AACxC,mBAAmB,cAAc;AACjC,oBAAoB,eAAe;AACnC,4BAA4B,eAAe;AAC3C,wBAAwB,eAAe;AACvC,gBAAgB,eAAe;AAC/B,uBAAuB,eAAe;AACtC,6BAA6B,eAAe;AAC5C,6BAA6B,eAAe;AAC5C,kCAAkC,eAAe;AACjD,oCAAoC,eAAe;AACnD,sCAAsC,eAAe;AACrD,mBAAmB,eAAe;AAClC,sBAAsB,eAAe;AACrC,sBAAsB,eAAe;AACrC,sBAAsB;AACtB;;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;;AAaC;;;ACnToK;;AAErK;AACA,SAAS,aAAa,0BAA0B,oBAAoB,GAAG,sBAAsB;;AAE7F;;AAEA,wBAAwB,eAAe;AACvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA,qBAAqB,8DAA8D;AACnF;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA,gEAAgE,uFAAuF;AACvJ,IAAI,wCAAwC;;AAE5C,qDAAqD,kCAAkC;AACvF;;AAEA;AACA;;AAEA,0EAAe;AACf;AACA;AACA;AACA;AACA,kBAAkB,mCAAmC;AACrD,kCAAkC,EAAE,eAAe;AACnD,qBAAqB,uBAAuB;AAC5C,8BAA8B,sDAAsD;AACpF,+BAA+B,aAAa;AAC5C,gCAAgC,aAAa;AAC7C,6BAA6B,eAAe;AAC5C,yBAAyB,eAAe;AACxC,8BAA8B,aAAa;AAC3C,8BAA8B,eAAe;AAC7C,gCAAgC,eAAe;AAC/C,uCAAuC;AACvC,SAAS;AACT,OAAO;AACP;AACA;AACA,kBAAkB,qCAAqC;AACvD,kCAAkC,EAAE,eAAe;AACnD,qBAAqB,uBAAuB;AAC5C,8BAA8B,wDAAwD;AACtF,+BAA+B,aAAa;AAC5C,gCAAgC,aAAa;AAC7C,6BAA6B,eAAe;AAC5C,yBAAyB,eAAe;AACxC,0BAA0B,eAAe;AACzC,2BAA2B,eAAe;AAC1C,8BAA8B,aAAa;AAC3C,gCAAgC,eAAe;AAC/C,uCAAuC;AACvC,SAAS;AACT;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,qDAAqD,yBAAyB;AAC9E,kCAAkC,EAAE,kBAAkB;AACtD;AACA;AACA;AACA;AACA,4BAA4B,yBAAyB;AACrD;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA,qDAAqD,yBAAyB;AAC9E,kCAAkC,EAAE,kBAAkB;AACtD;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,yBAAyB;AACrD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,CAAC;;;AClID;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,qFAAqF;AACrF;AACA;AACA;AACA;AACA;;AAE2M;;AAE3M;AACA,EAAE,aAAa;AACf,EAAE,oBAAoB;AACtB,EAAE,sBAAsB;;AAExB;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA,kCAAkC;AAClC;;AAEA;;AAEA,gEAAgE,uBAAuB;AACvF;;AAEA,yCAAyC,6BAA6B;AACtE;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,iCAAiC,8BAA8B;AAC/D,+BAA+B,qBAAqB;AACpD,kCAAkC,8BAA8B;AAChE;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,iEAAe;AACf;AACA;AACA;AACA,gBAAgB,qBAAqB;AACrC,gCAAgC,EAAE,eAAe;AACjD,mBAAmB,uBAAuB;AAC1C,qBAAqB,+CAA+C;AACpE,sBAAsB,uBAAuB;AAC7C,qCAAqC,uBAAuB;AAC5D,uCAAuC,uBAAuB;AAC9D,6BAA6B,aAAa;AAC1C,8BAA8B,aAAa;AAC3C,2BAA2B,eAAe;AAC1C,uBAAuB,eAAe;AACtC,wBAAwB,eAAe;AACvC,yBAAyB,eAAe;AACxC,4BAA4B,eAAe;AAC3C,8BAA8B,eAAe;AAC7C,qCAAqC,eAAe;AACpD,uBAAuB,aAAa;AACpC,wBAAwB,aAAa;AACrC,4BAA4B,aAAa;AACzC,yBAAyB,aAAa;AACtC,oBAAoB,aAAa;AACjC,+BAA+B,aAAa;AAC5C,gCAAgC,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":"AAAA,+CAA+C,mMAAmM,IAAI,GAAG,6BAA6B,aAAa,6DAA6D,6CAA6C,OAAO,6CAA6C,iLAAiL,iGAAiG,UAAU,OAAO,8CAA8C,yIAAyI,uDAAuD,UAAU,OAAO,qDAAqD,2LAA2L,4BAA4B,iFAAiF,WAAW,UAAU,EAAE,OAAO,0CAA0C,sJAAsJ,+CAA+C,4DAA4D,kFAAkF,aAAa,0CAA0C,iCAAiC,0BAA0B,YAAY,8CAA8C,8DAA8D,+CAA+C,kFAAkF,0DAA0D,mBAAmB,iBAAiB,eAAe,aAAa,0BAA0B,YAAY,UAAU,IAAI,OAAO,uGAAuG,iDAAiD,uDAAuD,oEAAoE,0CAA0C,kDAAkD,mCAAmC,WAAW,gEAAgE,+CAA+C,WAAW,SAAS,wDAAwD,4DAA4D,0CAA0C,kGAAkG,SAAS,2DAA2D,sDAAsD,0CAA0C,8CAA8C,8CAA8C,0DAA0D,kCAAkC,+CAA+C,aAAa,WAAW,SAAS,4CAA4C,sDAAsD,0CAA0C,oDAAoD,8CAA8C,gCAAgC,iDAAiD,+CAA+C,OAAO,QAAQ,6CAA6C,aAAa,WAAW,SAAS,QAAQ,EAAE,0BAA0B,kBAAkB,+BAA+B,yBAAyB,yBAAyB,0BAA0B,8BAA8B,iCAAiC,kCAAkC,2BAA2B,yBAAyB,6BAA6B,sBAAsB,qBAAqB,uBAAuB,wBAAwB,0BAA0B,qBAAqB,uBAAuB,yBAAyB,uBAAuB,2BAA2B,6BAA6B,gCAAgC,6BAA6B,2BAA2B,0BAA0B,+BAA+B,sCAAsC,0BAA0B,0BAA0B,yBAAyB,wBAAwB,6BAA6B,qCAAqC,6BAA6B,qCAAqC,6BAA6B,qCAAqC,6BAA6B,qCAAqC,qCAAqC,uBAAuB,wBAAwB,sBAAsB,2BAA2B,uBAAuB,8BAA8B,yBAAyB,0BAA0B,8BAA8B,yBAAyB,yBAAyB,0BAA0B,8BAA8B,gCAAgC,kCAAkC,8BAA8B,wBAAwB,oCAAoC,oCAAoC,+CAA+C,+CAA+C,yCAAyC,sCAAsC,sCAAsC,8BAA8B,mCAAmC,sCAAsC,6BAA6B,0CAA0C,yCAAyC,4BAA4B,yCAAyC,wCAAwC,gCAAgC,wBAAwB,yBAAyB,iCAAiC,uBAAuB,+BAA+B,yBAAyB,6BAA6B,qCAAqC,qCAAqC,oCAAoC,kCAAkC,2BAA2B,yBAAyB,0BAA0B,+BAA+B,oCAAoC,gCAAgC,2BAA2B,kCAAkC,oCAAoC,qCAAqC,qCAAqC,qCAAqC,uCAAuC,uCAAuC,wCAAwC,wCAAwC,+BAA+B,wBAAwB,0BAA0B,4BAA4B,mCAAmC,iCAAiC,iCAAiC,mCAAmC,+BAA+B,gCAAgC,8BAA8B,kCAAkC,gCAAgC,8BAA8B,4BAA4B,6BAA6B,4BAA4B,8BAA8B,6BAA6B,8BAA8B,4BAA4B,iCAAiC,gCAAgC,gIAAgI,iGAAiG,uIAAuI,2BAA2B,SAAS,QAAQ,kFAAkF,WAAW,8BAA8B,oDAAoD,kDAAkD,kDAAkD,kDAAkD,0cAA0c,YAAY,UAAU,iDAAiD,yDAAyD,SAAS,gJAAgJ,uCAAuC,SAAS,mHAAmH,6DAA6D,SAAS,kGAAkG,uCAAuC,SAAS,iGAAiG,mCAAmC,iCAAiC,0CAA0C,uCAAuC,SAAS,iDAAiD,mCAAmC,iCAAiC,0CAA0C,yDAAyD,SAAS,6FAA6F,wEAAwE,SAAS,6FAA6F,sDAAsD,SAAS,uGAAuG,iDAAiD,SAAS,yCAAyC,yCAAyC,SAAS,yCAAyC,yCAAyC,SAAS,2CAA2C,gEAAgE,SAAS,6CAA6C,0EAA0E,SAAS,8CAA8C,2EAA2E,SAAS,QAAQ,kPAAkP,wBAAwB,sBAAsB,OAAO,mDAAmD,oBAAoB,4BAA4B,0BAA0B,WAAW,oCAAoC,2BAA2B,WAAW,SAAS,sBAAsB,4BAA4B,0BAA0B,WAAW,oCAAoC,2BAA2B,WAAW,SAAS,QAAQ,EAAE,yCAAyC,wDAAwD,qBAAqB,mBAAmB,sBAAsB,SAAS,yCAAyC,0BAA0B,wBAAwB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,kDAAkD,4BAA4B,oCAAoC,MAAM,kCAAkC,MAAM,wEAAwE,WAAW,sBAAsB,SAAS,2CAA2C,4BAA4B,kCAAkC,gCAAgC,wEAAwE,WAAW,SAAS,6BAA6B,wDAAwD,SAAS,+BAA+B,uBAAuB,qBAAqB,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,sBAAsB,SAAS,6CAA6C,4BAA4B,0BAA0B,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,sBAAsB,SAAS,mCAAmC,wBAAwB,sBAAsB,sBAAsB,SAAS,8CAA8C,2BAA2B,yBAAyB,sBAAsB,SAAS,iCAAiC,wBAAwB,sBAAsB,sBAAsB,SAAS,4CAA4C,mDAAmD,SAAS,uCAAuC,qCAAqC,2BAA2B,oDAAoD,kDAAkD,sBAAsB,SAAS,8BAA8B,2CAA2C,yCAAyC,sBAAsB,SAAS,8BAA8B,2CAA2C,yCAAyC,sBAAsB,SAAS,uCAAuC,6GAA6G,8DAA8D,sBAAsB,SAAS,mCAAmC,kCAAkC,gCAAgC,yDAAyD,sCAAsC,oCAAoC,0CAA0C,YAAY,SAAS,+CAA+C,qCAAqC,6GAA6G,SAAS,6BAA6B,wCAAwC,sCAAsC,sBAAsB,SAAS,4BAA4B,uCAAuC,qCAAqC,sBAAsB,SAAS,6BAA6B,wCAAwC,sCAAsC,sBAAsB,SAAS,mCAAmC,+EAA+E,6EAA6E,sBAAsB,SAAS,8BAA8B,4BAA4B,0BAA0B,sBAAsB,SAAS,8BAA8B,6CAA6C,SAAS,gCAAgC,mDAAmD,SAAS,8BAA8B,gEAAgE,SAAS,uCAAuC,yDAAyD,SAAS,iCAAiC,yDAAyD,SAAS,6BAA6B,iIAAiI,gDAAgD,uBAAuB,SAAS,qCAAqC,0DAA0D,SAAS,4CAA4C,mDAAmD,iCAAiC,SAAS,8CAA8C,qEAAqE,SAAS,yCAAyC,2DAA2D,SAAS,sCAAsC,6CAA6C,2CAA2C,sBAAsB,SAAS,kDAAkD,6EAA6E,SAAS,iCAAiC,8DAA8D,SAAS,gDAAgD,iDAAiD,mCAAmC,qCAAqC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,mCAAmC,qCAAqC,uBAAuB,SAAS,qEAAqE,uCAAuC,kGAAkG,WAAW,2CAA2C,yCAAyC,sBAAsB,SAAS,mDAAmD,2DAA2D,oCAAoC,kCAAkC,4CAA4C,0CAA0C,sBAAsB,SAAS,QAAQ,EAAE,yhBAAyhB,gHAAgH,qCAAqC,2GAA2G,SAAS,OAAO,yCAAyC,kIAAkI,iCAAiC,yBAAyB,eAAe,eAAe,eAAe,uBAAuB,eAAe,eAAe,eAAe,uBAAuB,eAAe,gBAAgB,eAAe,uBAAuB,eAAe,gBAAgB,eAAe,sBAAsB,SAAS,gCAAgC,oHAAoH,sBAAsB,SAAS,6BAA6B,0DAA0D,SAAS,+BAA+B,iCAAiC,4BAA4B,6BAA6B,mBAAmB,mBAAmB,kBAAkB,2BAA2B,mBAAmB,mBAAmB,kBAAkB,2BAA2B,mBAAmB,qBAAqB,oBAAoB,6BAA6B,qBAAqB,qBAAqB,oBAAoB,sBAAsB,SAAS,uCAAuC,kDAAkD,8BAA8B,4BAA4B,4BAA4B,sBAAsB,SAAS,yDAAyD,+CAA+C,6CAA6C,6CAA6C,sBAAsB,SAAS,sDAAsD,sKAAsK,sBAAsB,SAAS,uCAAuC,iCAAiC,gDAAgD,mCAAmC,8BAA8B,qEAAqE,mEAAmE,mEAAmE,uCAAuC,qCAAqC,qCAAqC,uCAAuC,qCAAqC,qCAAqC,uCAAuC,qCAAqC,uCAAuC,wBAAwB,YAAY,SAAS,sDAAsD,+CAA+C,qIAAqI,WAAW,iCAAiC,oDAAoD,iDAAiD,iDAAiD,iDAAiD,wCAAwC,+DAA+D,4BAA4B,4BAA4B,sBAAsB,kCAAkC,gCAAgC,4BAA4B,kCAAkC,gCAAgC,2BAA2B,YAAY,mCAAmC,+DAA+D,kCAAkC,gCAAgC,0BAA0B,4BAA4B,0BAA0B,wBAAwB,kCAAkC,gCAAgC,2BAA2B,YAAY,mCAAmC,+DAA+D,kCAAkC,4BAA4B,gCAAgC,kCAAkC,0BAA0B,gCAAgC,8BAA8B,sBAAsB,2BAA2B,YAAY,mCAAmC,+DAA+D,4BAA4B,gCAAgC,gCAAgC,4BAA4B,gCAAgC,gCAAgC,0BAA0B,0BAA0B,2BAA2B,YAAY,mCAAmC,+DAA+D,4BAA4B,gCAAgC,gCAAgC,wBAAwB,0BAA0B,4BAA4B,8BAA8B,gCAAgC,iCAAiC,YAAY,mCAAmC,+DAA+D,4BAA4B,wBAAwB,0BAA0B,kCAAkC,0BAA0B,gCAAgC,kCAAkC,0BAA0B,iCAAiC,WAAW,4CAA4C,oBAAoB,qBAAqB,4CAA4C,qBAAqB,qBAAqB,qBAAqB,sBAAsB,SAAS,qDAAqD,iCAAiC,qDAAqD,+CAA+C,kDAAkD,kDAAkD,kDAAkD,oCAAoC,0BAA0B,0BAA0B,4BAA4B,kCAAkC,0BAA0B,4BAA4B,0BAA0B,mCAAmC,4CAA4C,oBAAoB,qBAAqB,4CAA4C,qBAAqB,qBAAqB,qBAAqB,sBAAsB,SAAS,8BAA8B,gCAAgC,8BAA8B,8BAA8B,qDAAqD,mCAAmC,wCAAwC,uCAAuC,8EAA8E,aAAa,0BAA0B,kCAAkC,uCAAuC,mFAAmF,8BAA8B,gBAAgB,MAAM,8BAA8B,eAAe,4BAA4B,oCAAoC,aAAa,0BAA0B,iCAAiC,2BAA2B,eAAe,cAAc,yBAAyB,eAAe,cAAc,yBAAyB,eAAe,eAAe,wBAAwB,YAAY,SAAS,wCAAwC,kCAAkC,+HAA+H,+CAA+C,WAAW,kDAAkD,SAAS,sCAAsC,kDAAkD,SAAS,8CAA8C,8BAA8B,4BAA4B,+BAA+B,0EAA0E,wEAAwE,yEAAyE,yEAAyE,0EAA0E,wEAAwE,yEAAyE,yEAAyE,kEAAkE,gEAAgE,gEAAgE,iEAAiE,kEAAkE,gEAAgE,gEAAgE,iEAAiE,kEAAkE,gEAAgE,iEAAiE,iEAAiE,kEAAkE,gEAAgE,iEAAiE,iEAAiE,sBAAsB,SAAS,yCAAyC,iCAAiC,wBAAwB,cAAc,cAAc,cAAc,sBAAsB,cAAc,cAAc,cAAc,sBAAsB,cAAc,eAAe,cAAc,sBAAsB,cAAc,eAAe,cAAc,sBAAsB,SAAS,8CAA8C,iCAAiC,+DAA+D,kDAAkD,OAAO,QAAQ,yCAAyC,uCAAuC,uCAAuC,sCAAsC,sDAAsD,aAAa,6BAA6B,YAAY,SAAS,qCAAqC,iCAAiC,0EAA0E,wEAAwE,yEAAyE,yEAAyE,q/BAAq/B,SAAS,iCAAiC,iCAAiC,gBAAgB,yBAAyB,mBAAmB,cAAc,uBAAuB,mBAAmB,cAAc,uBAAuB,mBAAmB,cAAc,yBAAyB,oBAAoB,eAAe,uBAAuB,oBAAoB,eAAe,wBAAwB,qBAAqB,eAAe,sBAAsB,SAAS,sCAAsC,iCAAiC,yBAAyB,uBAAuB,uBAAuB,sBAAsB,SAAS,wDAAwD,y6BAAy6B,kEAAkE,4BAA4B,6FAA6F,+CAA+C,qCAAqC,cAAc,MAAM,kCAAkC,aAAa,mCAAmC,WAAW,+BAA+B,iCAAiC,yIAAyI,yIAAyI,yIAAyI,iCAAiC,yIAAyI,yIAAyI,yIAAyI,iCAAiC,yIAAyI,0IAA0I,0IAA0I,kCAAkC,0IAA0I,0IAA0I,0IAA0I,sBAAsB,SAAS,gCAAgC,iCAAiC,sCAAsC,wBAAwB,cAAc,aAAa,sBAAsB,cAAc,aAAa,sBAAsB,cAAc,cAAc,sBAAsB,cAAc,cAAc,sBAAsB,SAAS,yCAAyC,iCAAiC,mFAAmF,iFAAiF,mFAAmF,uEAAuE,SAAS,gDAAgD,oHAAoH,sBAAsB,SAAS,4CAA4C,2DAA2D,sHAAsH,sBAAsB,SAAS,4CAA4C,2DAA2D,yHAAyH,sBAAsB,SAAS,4CAA4C,2DAA2D,sHAAsH,sBAAsB,SAAS,qDAAqD,mHAAmH,kCAAkC,sBAAsB,+CAA+C,mCAAmC,gOAAgO,uBAAuB,SAAS,0CAA0C,oHAAoH,sBAAsB,SAAS,0CAA0C,oHAAoH,sBAAsB,SAAS,4DAA4D,wDAAwD,4BAA4B,qCAAqC,sBAAsB,SAAS,iCAAiC,qCAAqC,mCAAmC,oEAAoE,mCAAmC,sEAAsE,oEAAoE,qEAAqE,2GAA2G,mCAAmC,kCAAkC,gCAAgC,gCAAgC,oEAAoE,+BAA+B,6BAA6B,6BAA6B,0CAA0C,wCAAwC,wCAAwC,0CAA0C,wCAAwC,wCAAwC,0CAA0C,wCAAwC,yCAAyC,uDAAuD,yBAAyB,uBAAuB,uBAAuB,wBAAwB,YAAY,SAAS,8EAA8E,oCAAoC,mIAAmI,WAAW,iCAAiC,4CAA4C,4CAA4C,sDAAsD,oDAAoD,kDAAkD,kDAAkD,sBAAsB,cAAc,cAAc,eAAe,oBAAoB,cAAc,cAAc,eAAe,oBAAoB,cAAc,eAAe,eAAe,oBAAoB,cAAc,iBAAiB,eAAe,sBAAsB,SAAS,6EAA6E,iCAAiC,uCAAuC,uCAAuC,qCAAqC,uCAAuC,qCAAqC,mCAAmC,0BAA0B,cAAc,cAAc,iBAAiB,oBAAoB,kBAAkB,cAAc,iBAAiB,oBAAoB,cAAc,qBAAqB,iBAAiB,oBAAoB,cAAc,eAAe,eAAe,sBAAsB,SAAS,sCAAsC,iCAAiC,iCAAiC,2BAA2B,QAAQ,QAAQ,oDAAoD,WAAW,sBAAsB,SAAS,gDAAgD,iDAAiD,2BAA2B,QAAQ,QAAQ,qDAAqD,WAAW,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,iCAAiC,oCAAoC,sCAAsC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,wCAAwC,wCAAwC,0CAA0C,wCAAwC,wCAAwC,wCAAwC,uBAAuB,SAAS,QAAQ,EAAE,+PAA+P,yBAAyB,uBAAuB,uBAAuB,4CAA4C,OAAO,kCAAkC,2CAA2C,8CAA8C,SAAS,wFAAwF,oXAAoX,mEAAmE,kKAAkK,iHAAiH,6FAA6F,4CAA4C,0CAA0C,aAAa,+BAA+B,oCAAoC,kCAAkC,kCAAkC,kCAAkC,kFAAkF,6EAA6E,sBAAsB,oBAAoB,oBAAoB,oBAAoB,aAAa,WAAW,gCAAgC,kCAAkC,kCAAkC,kCAAkC,SAAS,QAAQ,EAAE,sDAAsD,YAAY,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,aAAa,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,aAAa,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,aAAa,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,QAAQ,EAAE,4CAA4C,sCAAsC,sBAAsB,oBAAoB,oBAAoB,oBAAoB,kCAAkC,sBAAsB,SAAS,6BAA6B,4EAA4E,SAAS,wCAAwC,iCAAiC,+BAA+B,+BAA+B,+BAA+B,kCAAkC,sBAAsB,SAAS,mDAAmD,+CAA+C,kIAAkI,WAAW,4EAA4E,0NAA0N,2BAA2B,gCAAgC,8BAA8B,8BAA8B,gCAAgC,8BAA8B,8BAA8B,kCAAkC,kDAAkD,gDAAgD,gDAAgD,gDAAgD,YAAY,6BAA6B,kDAAkD,gDAAgD,gDAAgD,gDAAgD,YAAY,6BAA6B,kDAAkD,gDAAgD,gDAAgD,gDAAgD,YAAY,6BAA6B,kDAAkD,gDAAgD,gDAAgD,gDAAgD,YAAY,6BAA6B,kDAAkD,gDAAgD,gDAAgD,gDAAgD,YAAY,6BAA6B,kDAAkD,gDAAgD,gDAAgD,gDAAgD,WAAW,0DAA0D,sBAAsB,SAAS,qDAAqD,iNAAiN,+BAA+B,6BAA6B,6BAA6B,wCAAwC,kCAAkC,sBAAsB,SAAS,gDAAgD,gbAAgb,4BAA4B,+CAA+C,+BAA+B,sCAAsC,sCAAsC,sCAAsC,YAAY,oCAAoC,yDAAyD,wCAAwC,6BAA6B,sCAAsC,sCAAsC,YAAY,uBAAuB,yDAAyD,wCAAwC,sCAAsC,6BAA6B,sCAAsC,YAAY,MAAM,yDAAyD,wCAAwC,sCAAsC,sCAAsC,6BAA6B,WAAW,kCAAkC,sBAAsB,SAAS,0CAA0C,oGAAoG,cAAc,6BAA6B,4DAA4D,uDAAuD,qCAAqC,4BAA4B,oBAAoB,gEAAgE,gDAAgD,gBAAgB,MAAM,gDAAgD,eAAe,cAAc,MAAM,4CAA4C,aAAa,2BAA2B,yBAAyB,yBAAyB,sBAAsB,oCAAoC,YAAY,SAAS,iCAAiC,8CAA8C,SAAS,iCAAiC,yBAAyB,uBAAuB,uBAAuB,kCAAkC,sBAAsB,SAAS,8BAA8B,mFAAmF,SAAS,gCAAgC,+FAA+F,SAAS,8BAA8B,4GAA4G,SAAS,iCAAiC,gCAAgC,0BAA0B,wBAAwB,sBAAsB,sBAAsB,sBAAsB,YAAY,MAAM,sBAAsB,kCAAkC,gCAAgC,gCAAgC,gCAAgC,WAAW,kCAAkC,sBAAsB,SAAS,sCAAsC,kCAAkC,qIAAqI,kDAAkD,WAAW,qDAAqD,SAAS,sCAAsC,qDAAqD,SAAS,iDAAiD,uKAAuK,2DAA2D,kEAAkE,gEAAgE,gEAAgE,gEAAgE,kCAAkC,sBAAsB,SAAS,oCAAoC,qCAAqC,8CAA8C,iEAAiE,wKAAwK,mCAAmC,8BAA8B,4BAA4B,4BAA4B,4BAA4B,0CAA0C,YAAY,MAAM,4BAA4B,WAAW,sCAAsC,wBAAwB,sBAAsB,sBAAsB,sBAAsB,wBAAwB,WAAW,4EAA4E,mDAAmD,4CAA4C,0CAA0C,0CAA0C,0CAA0C,wBAAwB,WAAW,mEAAmE,kIAAkI,sDAAsD,oDAAoD,oDAAoD,oDAAoD,kCAAkC,sBAAsB,SAAS,0CAA0C,kJAAkJ,SAAS,gDAAgD,iDAAiD,oCAAoC,sCAAsC,sCAAsC,sCAAsC,kCAAkC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,oCAAoC,sCAAsC,sCAAsC,sCAAsC,uBAAuB,SAAS,0CAA0C,2CAA2C,sBAAsB,SAAS,yCAAyC,QAAQ,EAAE,yVAAyV,wBAAwB,sBAAsB,sBAAsB,OAAO,yCAAyC,2DAA2D,qBAAqB,mBAAmB,mBAAmB,sBAAsB,SAAS,yCAAyC,0BAA0B,wBAAwB,wBAAwB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,kDAAkD,4BAA4B,oCAAoC,MAAM,kCAAkC,MAAM,kCAAkC,MAAM,wEAAwE,WAAW,sBAAsB,SAAS,2CAA2C,4BAA4B,kCAAkC,gCAAgC,gCAAgC,wEAAwE,WAAW,SAAS,6BAA6B,gEAAgE,SAAS,+BAA+B,uBAAuB,qBAAqB,qBAAqB,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,2BAA2B,sBAAsB,SAAS,6CAA6C,4BAA4B,0BAA0B,0BAA0B,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,2BAA2B,sBAAsB,SAAS,sCAAsC,kCAAkC,8HAA8H,8CAA8C,WAAW,wBAAwB,sBAAsB,sBAAsB,sBAAsB,SAAS,8CAA8C,2BAA2B,yBAAyB,yBAAyB,sBAAsB,SAAS,6CAA6C,6BAA6B,2BAA2B,2BAA2B,sBAAsB,SAAS,kCAAkC,4CAA4C,+CAA+C,iDAAiD,6HAA6H,aAAa,4EAA4E,YAAY,SAAS,wCAAwC,4CAA4C,yDAAyD,sFAAsF,YAAY,SAAS,yCAAyC,iDAAiD,2BAA2B,wDAAwD,sDAAsD,sDAAsD,sBAAsB,SAAS,uCAAuC,iDAAiD,2BAA2B,0EAA0E,0EAA0E,wEAAwE,yEAAyE,sBAAsB,SAAS,0CAA0C,iDAAiD,mDAAmD,gFAAgF,0CAA0C,0CAA0C,4CAA4C,2GAA2G,6DAA6D,6DAA6D,sBAAsB,SAAS,+BAA+B,qCAAqC,6CAA6C,wGAAwG,6CAA6C,YAAY,SAAS,mCAAmC,qCAAqC,+CAA+C,wGAAwG,6CAA6C,YAAY,SAAS,+CAA+C,4IAA4I,2BAA2B,wDAAwD,sDAAsD,uDAAuD,kCAAkC,SAAS,iCAAiC,wBAAwB,sBAAsB,sBAAsB,sBAAsB,SAAS,4CAA4C,mDAAmD,SAAS,8BAA8B,2CAA2C,yCAAyC,yCAAyC,sBAAsB,SAAS,8BAA8B,2CAA2C,yCAAyC,yCAAyC,sBAAsB,SAAS,uCAAuC,6GAA6G,8DAA8D,8DAA8D,sBAAsB,SAAS,mCAAmC,kCAAkC,gCAAgC,yDAAyD,8CAA8C,4CAA4C,0CAA0C,YAAY,SAAS,+CAA+C,qCAAqC,6GAA6G,SAAS,6BAA6B,wCAAwC,sCAAsC,sCAAsC,sBAAsB,SAAS,4BAA4B,uCAAuC,qCAAqC,qCAAqC,sBAAsB,SAAS,6BAA6B,wCAAwC,sCAAsC,sCAAsC,sBAAsB,SAAS,mCAAmC,+EAA+E,6EAA6E,6EAA6E,sBAAsB,SAAS,8BAA8B,4BAA4B,0BAA0B,0BAA0B,sBAAsB,SAAS,8BAA8B,4DAA4D,SAAS,8DAA8D,qEAAqE,SAAS,8BAA8B,kFAAkF,SAAS,uCAAuC,8EAA8E,SAAS,iCAAiC,yDAAyD,SAAS,yCAAyC,2DAA2D,SAAS,sCAAsC,6CAA6C,2CAA2C,2CAA2C,sBAAsB,SAAS,kDAAkD,6EAA6E,SAAS,mCAAmC,kCAAkC,wHAAwH,2CAA2C,WAAW,8CAA8C,SAAS,0CAA0C,2CAA2C,yCAAyC,qCAAqC,mCAAmC,mCAAmC,sBAAsB,SAAS,+CAA+C,8DAA8D,8DAA8D,SAAS,sCAAsC,iCAAiC,yDAAyD,2DAA2D,kCAAkC,YAAY,SAAS,iCAAiC,oJAAoJ,6CAA6C,0FAA0F,YAAY,SAAS,oCAAoC,sFAAsF,2GAA2G,SAAS,qCAAqC,0DAA0D,SAAS,4CAA4C,sEAAsE,6CAA6C,SAAS,8CAA8C,gGAAgG,SAAS,2CAA2C,0DAA0D,sDAAsD,8CAA8C,oDAAoD,sBAAsB,SAAS,6CAA6C,kDAAkD,qBAAqB,gDAAgD,sBAAsB,SAAS,gDAAgD,6BAA6B,2BAA2B,yBAAyB,yBAAyB,sBAAsB,SAAS,6CAA6C,6DAA6D,2DAA2D,2DAA2D,sBAAsB,oBAAoB,oBAAoB,sBAAsB,SAAS,qDAAqD,yDAAyD,SAAS,iCAAiC,oFAAoF,SAAS,gDAAgD,iDAAiD,mCAAmC,qCAAqC,qCAAqC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,mCAAmC,qCAAqC,qCAAqC,uBAAuB,SAAS,qEAAqE,uCAAuC,kGAAkG,WAAW,2CAA2C,yCAAyC,yCAAyC,sBAAsB,SAAS,QAAQ,EAAE,oNAAoN,oFAAoF,qCAAqC,2GAA2G,SAAS,OAAO,yCAAyC,+FAA+F,iCAAiC,yBAAyB,eAAe,cAAc,uBAAuB,eAAe,cAAc,uBAAuB,eAAe,cAAc,sBAAsB,SAAS,gCAAgC,sFAAsF,sBAAsB,SAAS,6BAA6B,mEAAmE,SAAS,+BAA+B,iCAAiC,4BAA4B,6BAA6B,mBAAmB,kBAAkB,2BAA2B,mBAAmB,kBAAkB,2BAA2B,mBAAmB,kBAAkB,sBAAsB,SAAS,yCAAyC,8BAA8B,6IAA6I,sBAAsB,SAAS,8CAA8C,iCAAiC,+DAA+D,kDAAkD,OAAO,QAAQ,yCAAyC,uCAAuC,uCAAuC,sCAAsC,sDAAsD,aAAa,6BAA6B,YAAY,SAAS,qCAAqC,kDAAkD,SAAS,sCAAsC,kDAAkD,SAAS,8CAA8C,8BAA8B,4BAA4B,+BAA+B,0DAA0D,wDAAwD,wDAAwD,0DAA0D,wDAAwD,wDAAwD,sDAAsD,oDAAoD,oDAAoD,sDAAsD,oDAAoD,oDAAoD,sDAAsD,oDAAoD,oDAAoD,sBAAsB,SAAS,yCAAyC,iCAAiC,wBAAwB,cAAc,aAAa,sBAAsB,cAAc,aAAa,sBAAsB,cAAc,aAAa,sBAAsB,SAAS,mCAAmC,iCAAiC,oJAAoJ,uFAAuF,SAAS,6DAA6D,6CAA6C,kGAAkG,WAAW,4YAA4Y,4BAA4B,6FAA6F,+CAA+C,qCAAqC,cAAc,MAAM,kCAAkC,aAAa,mCAAmC,WAAW,+BAA+B,iCAAiC,qDAAqD,qDAAqD,iCAAiC,qDAAqD,qDAAqD,iCAAiC,qDAAqD,qDAAqD,sBAAsB,SAAS,iCAAiC,qCAAqC,wBAAwB,iBAAiB,aAAa,sBAAsB,iBAAiB,aAAa,sBAAsB,iBAAiB,aAAa,sBAAsB,SAAS,gDAAgD,+EAA+E,SAAS,6CAA6C,gCAAgC,0BAA0B,wBAAwB,wBAAwB,wBAAwB,wBAAwB,wBAAwB,wBAAwB,wBAAwB,wBAAwB,sBAAsB,SAAS,wEAAwE,uCAAuC,qCAAqC,gLAAgL,SAAS,qCAAqC,iCAAiC,yBAAyB,eAAe,cAAc,uBAAuB,eAAe,cAAc,sBAAsB,SAAS,qCAAqC,oCAAoC,kCAAkC,iCAAiC,0DAA0D,wDAAwD,sCAAsC,oCAAoC,oCAAoC,wCAAwC,sCAAsC,sCAAsC,sBAAsB,SAAS,yCAAyC,iCAAiC,mCAAmC,yBAAyB,wBAAwB,iCAAiC,yBAAyB,wBAAwB,sBAAsB,SAAS,sCAAsC,iCAAiC,iCAAiC,2BAA2B,OAAO,QAAQ,oDAAoD,WAAW,sBAAsB,SAAS,gDAAgD,iDAAiD,2BAA2B,OAAO,QAAQ,qDAAqD,WAAW,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,iCAAiC,oCAAoC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,sCAAsC,uBAAuB,SAAS,QAAQ,EAAE,uLAAuL,kHAAkH,6CAA6C,sBAAsB,EAAE,yCAAyC,uBAAuB,yEAAyE,wBAAwB,iFAAiF,uEAAuE,qEAAqE,4EAA4E,sFAAsF,oEAAoE,iEAAiE,+DAA+D,0CAA0C,wCAAwC,wCAAwC,wBAAwB,qCAAqC,kCAAkC,oCAAoC,oCAAoC,wBAAwB,+BAA+B,yeAAye,yBAAyB,2BAA2B,OAAO,wCAAwC,wCAAwC,sFAAsF,iFAAiF,qDAAqD,SAAS,oCAAoC,kCAAkC,oCAAoC,iDAAiD,wCAAwC,oCAAoC,kCAAkC,4CAA4C,0CAA0C,8CAA8C,sCAAsC,gCAAgC,4CAA4C,0CAA0C,0CAA0C,wCAAwC,0DAA0D,0CAA0C,wDAAwD,wDAAwD,kCAAkC,sDAAsD,wCAAwC,sBAAsB,SAAS,oCAAoC,gFAAgF,6EAA6E,8CAA8C,WAAW,wCAAwC,uBAAuB,uDAAuD,6BAA6B,cAAc,MAAM,4FAA4F,uCAAuC,yCAAyC,sDAAsD,iDAAiD,oDAAoD,gBAAgB,MAAM,4EAA4E,eAAe,aAAa,gEAAgE,2DAA2D,cAAc,MAAM,qDAAqD,aAAa,WAAW,wBAAwB,qBAAqB,uGAAuG,0dAA0d,2CAA2C,2EAA2E,6CAA6C,iDAAiD,mBAAmB,8EAA8E,2CAA2C,mFAAmF,aAAa,sCAAsC,WAAW,iCAAiC,gDAAgD,WAAW,wBAAwB,SAAS,+BAA+B,gCAAgC,kBAAkB,EAAE,SAAS,uCAAuC,mDAAmD,yCAAyC,uCAAuC,mCAAmC,mFAAmF,oBAAoB,+EAA+E,oBAAoB,2GAA2G,kDAAkD,kBAAkB,MAAM,mDAAmD,iBAAiB,oBAAoB,aAAa,WAAW,uCAAuC,mCAAmC,mFAAmF,oBAAoB,+EAA+E,oBAAoB,2GAA2G,kDAAkD,kBAAkB,MAAM,mDAAmD,iBAAiB,oBAAoB,aAAa,WAAW,6BAA6B,4BAA4B,WAAW,SAAS,QAAQ,EAAE,kEAAkE,iCAAiC,gDAAgD,SAAS,QAAQ,EAAE,yTAAyT,wBAAwB,sBAAsB,sBAAsB,2CAA2C,OAAO,yCAAyC,8DAA8D,qBAAqB,mBAAmB,mBAAmB,mBAAmB,sBAAsB,SAAS,yCAAyC,0BAA0B,wBAAwB,wBAAwB,wBAAwB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,+BAA+B,qBAAqB,sBAAsB,SAAS,kDAAkD,4BAA4B,oCAAoC,MAAM,kCAAkC,MAAM,kCAAkC,MAAM,kCAAkC,MAAM,wEAAwE,WAAW,sBAAsB,SAAS,2CAA2C,4BAA4B,kCAAkC,gCAAgC,gCAAgC,gCAAgC,wEAAwE,WAAW,SAAS,6BAA6B,wEAAwE,SAAS,+BAA+B,uBAAuB,qBAAqB,qBAAqB,iDAAiD,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,oBAAoB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,2BAA2B,2BAA2B,sBAAsB,SAAS,6CAA6C,4BAA4B,0BAA0B,0BAA0B,0BAA0B,sBAAsB,SAAS,iCAAiC,kCAAkC,oHAAoH,yCAAyC,WAAW,wBAAwB,sBAAsB,sBAAsB,sBAAsB,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,oBAAoB,oBAAoB,sBAAsB,SAAS,wCAAwC,6BAA6B,2BAA2B,2BAA2B,2BAA2B,sBAAsB,SAAS,8CAA8C,2BAA2B,yBAAyB,yBAAyB,yBAAyB,sBAAsB,SAAS,uCAAuC,6DAA6D,2BAA2B,sEAAsE,oEAAoE,qEAAqE,qEAAqE,sBAAsB,SAAS,4CAA4C,mDAAmD,SAAS,qDAAqD,6LAA6L,6CAA6C,6BAA6B,uBAAuB,qBAAqB,qBAAqB,YAAY,MAAM,6BAA6B,2BAA2B,2BAA2B,WAAW,sBAAsB,SAAS,yDAAyD,mkBAAmkB,4JAA4J,0YAA0Y,sGAAsG,2BAA2B,0CAA0C,oFAAoF,qCAAqC,mCAAmC,mCAAmC,qCAAqC,qCAAqC,qCAAqC,+CAA+C,oFAAoF,sBAAsB,8BAA8B,8BAA8B,gBAAgB,MAAM,oCAAoC,yBAAyB,yBAAyB,eAAe,cAAc,qBAAqB,oFAAoF,gCAAgC,oBAAoB,8BAA8B,gBAAgB,MAAM,oCAAoC,yBAAyB,yBAAyB,eAAe,cAAc,MAAM,2GAA2G,gCAAgC,8BAA8B,oBAAoB,gBAAgB,MAAM,oCAAoC,yBAAyB,yBAAyB,eAAe,aAAa,uCAAuC,yBAAyB,qCAAqC,2QAA2Q,iEAAiE,8MAA8M,mCAAmC,mCAAmC,0DAA0D,sBAAsB,SAAS,8BAA8B,2CAA2C,yCAAyC,yCAAyC,yCAAyC,sBAAsB,SAAS,8BAA8B,2CAA2C,yCAAyC,yCAAyC,yCAAyC,sBAAsB,SAAS,uCAAuC,6GAA6G,8DAA8D,8DAA8D,8DAA8D,sBAAsB,SAAS,mCAAmC,uBAAuB,yDAAyD,sCAAsC,kCAAkC,gCAAgC,aAAa,sDAAsD,oDAAoD,0CAA0C,YAAY,SAAS,+CAA+C,qCAAqC,6GAA6G,SAAS,6BAA6B,wCAAwC,sCAAsC,sCAAsC,sCAAsC,sBAAsB,SAAS,4BAA4B,uCAAuC,qCAAqC,qCAAqC,qCAAqC,sBAAsB,SAAS,6BAA6B,wCAAwC,sCAAsC,sCAAsC,sCAAsC,sBAAsB,SAAS,mCAAmC,+EAA+E,6EAA6E,6EAA6E,6EAA6E,sBAAsB,SAAS,8BAA8B,4BAA4B,0BAA0B,0BAA0B,0BAA0B,sBAAsB,SAAS,8BAA8B,2EAA2E,SAAS,gCAAgC,uFAAuF,SAAS,8BAA8B,oGAAoG,SAAS,uCAAuC,mGAAmG,SAAS,iCAAiC,yDAAyD,SAAS,yCAAyC,2DAA2D,SAAS,sCAAsC,6CAA6C,2CAA2C,2CAA2C,2CAA2C,sBAAsB,SAAS,kDAAkD,6EAA6E,SAAS,iCAAiC,0GAA0G,SAAS,gDAAgD,iDAAiD,mCAAmC,qCAAqC,qCAAqC,qCAAqC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,mCAAmC,qCAAqC,qCAAqC,qCAAqC,uBAAuB,SAAS,qEAAqE,uCAAuC,kGAAkG,WAAW,2CAA2C,yCAAyC,yCAAyC,yCAAyC,sBAAsB,SAAS,QAAQ,EAAE,6aAA6a,yCAAyC,2BAA2B,2BAA2B,0DAA0D,+BAA+B,2DAA2D,gCAAgC,gFAAgF,mMAAmM,0FAA0F,8FAA8F,2FAA2F,OAAO,gGAAgG,sHAAsH,iEAAiE,+BAA+B,+BAA+B,2BAA2B,WAAW,mDAAmD,gDAAgD,SAAS,6BAA6B,qDAAqD,SAAS,oCAAoC,oCAAoC,oCAAoC,gDAAgD,gDAAgD,gDAAgD,kDAAkD,gDAAgD,sBAAsB,SAAS,+BAA+B,gCAAgC,kBAAkB,EAAE,SAAS,QAAQ,EAAE,kIAAkI,+DAA+D,iCAAiC,sEAAsE,OAAO,qFAAqF,wEAAwE,qEAAqE,uMAAuM,oHAAoH,uBAAuB,2CAA2C,6EAA6E,2EAA2E,qCAAqC,yBAAyB,+BAA+B,OAAO,iEAAiE,oDAAoD,iDAAiD,iLAAiL,oDAAoD,wEAAwE,sHAAsH,2BAA2B,OAAO,iEAAiE,oDAAoD,iDAAiD,+DAA+D,0BAA0B,4BAA4B,SAAS,kCAAkC,6BAA6B,SAAS,QAAQ,EAAE,62CAA62C,6CAA6C,6FAA6F,sBAAsB,oBAAoB,OAAO,yHAAyH,2BAA2B,4GAA4G,0CAA0C,2GAA2G,mCAAmC,4DAA4D,gKAAgK,gCAAgC,oCAAoC,+BAA+B,SAAS,8BAA8B,oCAAoC,uCAAuC,eAAe,QAAQ,gCAAgC,0CAA0C,WAAW,SAAS,iBAAiB,OAAO,6EAA6E,mCAAmC,gCAAgC,kCAAkC,+BAA+B,SAAS,yBAAyB,SAAS,mDAAmD,iBAAiB,OAAO,uMAAuM,qCAAqC,OAAO,oCAAoC,qCAAqC,OAAO,oGAAoG,kCAAkC,wCAAwC,UAAU,MAAM,8CAA8C,SAAS,OAAO,qCAAqC,kCAAkC,mDAAmD,UAAU,+BAA+B,mDAAmD,UAAU,MAAM,wCAAwC,SAAS,OAAO,qCAAqC,kCAAkC,wCAAwC,UAAU,MAAM,yDAAyD,SAAS,OAAO,wFAAwF,iEAAiE,OAAO,qCAAqC,yCAAyC,qDAAqD,UAAU,MAAM,sCAAsC,2DAA2D,SAAS,OAAO,qCAAqC,yCAAyC,qDAAqD,UAAU,MAAM,sCAAsC,2DAA2D,SAAS,OAAO,iFAAiF,+CAA+C,sCAAsC,uDAAuD,OAAO,8CAA8C,+CAA+C,sCAAsC,6DAA6D,OAAO,8GAA8G,sCAAsC,OAAO,qCAAqC,sCAAsC,OAAO,qCAAqC,sCAAsC,OAAO,wGAAwG,yBAAyB,0CAA0C,iDAAiD,iDAAiD,iDAAiD,mDAAmD,iDAAiD,iDAAiD,+DAA+D,2EAA2E,sEAAsE,kEAAkE,8DAA8D,8DAA8D,iBAAiB,OAAO,8DAA8D,sCAAsC,OAAO,mCAAmC,sCAAsC,OAAO,2FAA2F,+DAA+D,OAAO,qCAAqC,+DAA+D,OAAO,qCAAqC,+DAA+D,OAAO,2FAA2F,4EAA4E,OAAO,qCAAqC,4EAA4E,OAAO,qCAAqC,6EAA6E,OAAO,qFAAqF,sEAAsE,0CAA0C,yBAAyB,SAAS,QAAQ,sEAAsE,SAAS,OAAO,+CAA+C,sEAAsE,0CAA0C,yBAAyB,SAAS,QAAQ,4EAA4E,SAAS,OAAO,mHAAmH,yBAAyB,2CAA2C,iDAAiD,iDAAiD,iDAAiD,mDAAmD,iDAAiD,iDAAiD,mDAAmD,sDAAsD,uEAAuE,kEAAkE,8DAA8D,8DAA8D,iBAAiB,OAAO,sFAAsF,qBAAqB,uBAAuB,2DAA2D,wCAAwC,eAAe,yDAAyD,qBAAqB,uBAAuB,kCAAkC,4DAA4D,wCAAwC,eAAe,wCAAwC,qBAAqB,uCAAuC,gBAAgB,qEAAqE,oJAAoJ,yCAAyC,SAAS,QAAQ,2BAA2B,wCAAwC,SAAS,QAAQ,oJAAoJ,icAAic,4CAA4C,wDAAwD,OAAO,4DAA4D,oEAAoE,0GAA0G,kBAAkB,GAAG,8LAA8L,wCAAwC,mHAAmH,oPAAoP,kBAAkB,YAAY,MAAM,8HAA8H,uCAAuC,iDAAiD,0CAA0C,aAAa,6BAA6B,WAAW,SAAS,OAAO,8EAA8E,sCAAsC,iCAAiC,sEAAsE,yBAAyB,OAAO,QAAQ,0IAA0I,2CAA2C,SAAS,OAAO,uEAAuE,iCAAiC,sEAAsE,QAAQ,2EAA2E,+BAA+B,4DAA4D,QAAQ,gGAAgG,yCAAyC,SAAS,QAAQ,wDAAwD,0CAA0C,iHAAiH,WAAW,SAAS,QAAQ,6DAA6D,mBAAmB,yCAAyC,SAAS,QAAQ,2BAA2B,0CAA0C,SAAS,iBAAiB,QAAQ,sFAAsF,s7GAAs7G,iCAAiC,mDAAmD,yEAAyE,SAAS,sCAAsC,OAAO,uCAAuC,gFAAgF,yCAAyC,+BAA+B,YAAY,uCAAuC,iCAAiC,YAAY,uCAAuC,mCAAmC,WAAW,sBAAsB,SAAS,yCAAyC,0BAA0B,wBAAwB,wBAAwB,sBAAsB,SAAS,mCAAmC,kCAAkC,6CAA6C,0CAA0C,qCAAqC,sBAAsB,SAAS,uCAAuC,qBAAqB,mBAAmB,mBAAmB,sBAAsB,SAAS,8BAA8B,uCAAuC,gCAAgC,8BAA8B,wDAAwD,oCAAoC,oEAAoE,mBAAmB,WAAW,6CAA6C,wFAAwF,qCAAqC,qCAAqC,4BAA4B,2CAA2C,cAAc,MAAM,mEAAmE,kCAAkC,kDAAkD,wCAAwC,gDAAgD,aAAa,wBAAwB,YAAY,SAAS,yCAAyC,0CAA0C,+CAA+C,6CAA6C,+FAA+F,aAAa,WAAW,kBAAkB,0EAA0E,8CAA8C,4BAA4B,kCAAkC,6BAA6B,+KAA+K,8HAA8H,2EAA2E,2EAA2E,4CAA4C,8BAA8B,iBAAiB,uIAAuI,oIAAoI,2EAA2E,2EAA2E,4CAA4C,8BAA8B,iBAAiB,sBAAsB,iMAAiM,kHAAkH,yDAAyD,yDAAyD,4CAA4C,gDAAgD,iBAAiB,sBAAsB,aAAa,YAAY,qDAAqD,qDAAqD,gCAAgC,+BAA+B,kGAAkG,6EAA6E,6EAA6E,0BAA0B,cAAc,wBAAwB,qGAAqG,6EAA6E,6EAA6E,0BAA0B,aAAa,WAAW,4CAA4C,wEAAwE,sCAAsC,mDAAmD,cAAc,MAAM,gGAAgG,aAAa,WAAW,sBAAsB,SAAS,6BAA6B,gEAAgE,SAAS,mCAAmC,2BAA2B,yBAAyB,yBAAyB,sBAAsB,SAAS,6DAA6D,6DAA6D,oDAAoD,kDAAkD,kDAAkD,sBAAsB,SAAS,6DAA6D,6DAA6D,8EAA8E,oDAAoD,kDAAkD,kDAAkD,sBAAsB,SAAS,4CAA4C,iDAAiD,yBAAyB,uBAAuB,uBAAuB,sBAAsB,SAAS,4CAA4C,uCAAuC,qCAAqC,qCAAqC,sBAAsB,SAAS,8BAA8B,wFAAwF,SAAS,oCAAoC,0EAA0E,SAAS,8CAA8C,kFAAkF,mBAAmB,iDAAiD,wCAAwC,sCAAsC,8BAA8B,4CAA4C,8BAA8B,oBAAoB,yBAAyB,YAAY,MAAM,kCAAkC,8FAA8F,4BAA4B,mEAAmE,MAAM,iDAAiD,MAAM,iDAAiD,MAAM,aAAa,qBAAqB,WAAW,sBAAsB,2BAA2B,0BAA0B,qBAAqB,SAAS,gCAAgC,2HAA2H,SAAS,0CAA0C,kCAAkC,sBAAsB,YAAY,WAAW,6CAA6C,sBAAsB,SAAS,kCAAkC,4BAA4B,0BAA0B,0BAA0B,sBAAsB,SAAS,iDAAiD,uCAAuC,qCAAqC,qCAAqC,sBAAsB,SAAS,oCAAoC,sBAAsB,oBAAoB,oBAAoB,sBAAsB,SAAS,kCAAkC,mDAAmD,iDAAiD,iDAAiD,sBAAsB,SAAS,uCAAuC,4BAA4B,0BAA0B,0BAA0B,sBAAsB,SAAS,yCAAyC,sBAAsB,oBAAoB,oBAAoB,sBAAsB,SAAS,0CAA0C,iDAAiD,+CAA+C,+CAA+C,sBAAsB,SAAS,iCAAiC,gFAAgF,SAAS,gDAAgD,iDAAiD,mCAAmC,qCAAqC,qCAAqC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,mCAAmC,qCAAqC,qCAAqC,uBAAuB,SAAS,8BAA8B,+BAA+B,SAAS,QAAQ,EAAE,yFAAyF,iBAAiB,qBAAqB,8BAA8B,oBAAoB,YAAY,kBAAkB,aAAa,wBAAwB,sBAAsB,uBAAuB,aAAa,UAAU,uBAAuB,yBAAyB,aAAa,UAAU,kBAAkB,oBAAoB,aAAa,uBAAuB,YAAY,yBAAyB,YAAY,4BAA4B,aAAa,SAAS,iBAAiB,mBAAmB,aAAa,2BAA2B,UAAU,SAAS,oBAAoB,sBAAsB,aAAa,8BAA8B,UAAU,SAAS,uBAAuB,yBAAyB,aAAa,SAAS,mBAAmB,qBAAqB,aAAa,sBAAsB,UAAU,SAAS,qBAAqB,uBAAuB,aAAa,wBAAwB,4BAA4B,SAAS,2BAA2B,6BAA6B,aAAa,8BAA8B,UAAU,6BAA6B,UAAU,SAAS,wBAAwB,0BAA0B,aAAa,SAAS,wBAAwB,0BAA0B,aAAa,SAAS,uBAAuB,yBAAyB,aAAa,SAAS,eAAe,wBAAwB,gBAAgB,oBAAoB,UAAU,mBAAmB,aAAa,qBAAqB,8BAA8B,SAAS,kBAAkB,+BAA+B,WAAW,gCAAgC,wBAAwB,uBAAuB,oBAAoB,uBAAuB,yBAAyB,2BAA2B,4BAA4B,WAAW,mCAAmC,WAAW,oCAAoC,WAAW,yBAAyB,wBAAwB,mBAAmB,uBAAuB,wBAAwB,uBAAuB,sBAAsB,0BAA0B,oBAAoB,uBAAuB,yBAAyB,2BAA2B,4BAA4B,WAAW,4BAA4B,WAAW,6BAA6B,WAAW,0BAA0B,wBAAwB,mBAAmB,uBAAuB,oBAAoB,uBAAuB,uBAAuB,yBAAyB,2BAA2B,4BAA4B,+BAA+B,8BAA8B,WAAW,6BAA6B,WAAW,8BAA8B,WAAW,+BAA+B,wBAAwB,uBAAuB,uBAAuB,0BAA0B,WAAW,6HAA6H,wBAAwB,mBAAmB,uBAAuB,oBAAoB,qBAAqB,WAAW,SAAS,kBAAkB,qBAAqB,8BAA8B,oBAAoB,YAAY,iBAAiB,YAAY,kBAAkB,YAAY,gBAAgB,aAAa,wBAAwB,sBAAsB,SAAS,QAAQ,mEAAmE,sCAAsC,0BAA0B,2BAA2B,qBAAqB,QAAQ,kDAAkD,kCAAkC,qCAAqC,aAAa,WAAW,wBAAwB,SAAS,2CAA2C,gCAAgC,yCAAyC,mCAAmC,gDAAgD,yDAAyD,0QAA0Q,+DAA+D,gBAAgB,4CAA4C,+DAA+D,gBAAgB,MAAM,uDAAuD,eAAe,aAAa,WAAW,8BAA8B,SAAS,QAAQ,wGAAwG,eAAe,yFAAyF,eAAe,iGAAiG,eAAe,wIAAwI,yDAAyD,kIAAkI,4HAA4H,2BAA2B,gFAAgF,mCAAmC,YAAY,kEAAkE,MAAM,uEAAuE,MAAM,iKAAiK,iCAAiC,oIAAoI,0GAA0G,0DAA0D,gGAAgG,gBAAgB,iBAAiB,IAAI,4DAA4D,0CAA0C,IAAI,wEAAwE,qEAAqE,+DAA+D,IAAI,0FAA0F,+BAA+B,mEAAmE,mEAAmE,+BAA+B,IAAI,oGAAoG,+BAA+B,mEAAmE,mEAAmE,2CAA2C,IAAI,8DAA8D,+BAA+B,uDAAuD,gDAAgD,IAAI,8JAA8J,sCAAsC,6EAA6E,gFAAgF,yEAAyE,gEAAgE,wEAAwE,iDAAiD,6DAA6D,sCAAsC,2BAA2B,IAAI,8EAA8E,mCAAmC,4DAA4D,6CAA6C,wCAAwC,wGAAwG,qCAAqC,gBAAgB,IAAI,yDAAyD,4BAA4B,uDAAuD,IAAI,wEAAwE,8BAA8B,yBAAyB,uDAAuD,4CAA4C,sBAAsB,kFAAkF,8CAA8C,IAAI,8HAA8H,kDAAkD,kDAAkD,yCAAyC,6EAA6E,kBAAkB,4CAA4C,4BAA4B,2DAA2D,uBAAuB,kDAAkD,kDAAkD,kDAAkD,kDAAkD,6CAA6C,6CAA6C,6CAA6C,6CAA6C,0CAA0C,+EAA+E,+EAA+E,+EAA+E,+EAA+E,4EAA4E,oBAAoB,IAAI,oIAAoI,yEAAyE,4DAA4D,sDAAsD,mCAAmC,wEAAwE,kDAAkD,yCAAyC,IAAI,mCAAmC,kBAAkB,IAAI,yEAAyE,iFAAiF,IAAI,qKAAqK,6EAA6E,gEAAgE,wEAAwE,iDAAiD,yCAAyC,iDAAiD,2BAA2B,IAAI,qEAAqE,2DAA2D,IAAI,sEAAsE,mDAAmD,IAAI,MAAM,sFAAsF,8BAA8B,wBAAwB,kCAAkC,kCAAkC,6DAA6D,2EAA2E,2EAA2E,iCAAiC,OAAO,0EAA0E,2FAA2F,2FAA2F,6BAA6B,wCAAwC,wCAAwC,yCAAyC,qEAAqE,6DAA6D,OAAO,eAAe,yFAAyF,2BAA2B,QAAQ,0CAA0C,kEAAkE,OAAO,2FAA2F,8CAA8C,yBAAyB,QAAQ,6CAA6C,+EAA+E,UAAU,gCAAgC,iCAAiC,gKAAgK,qEAAqE,eAAe,qJAAqJ,eAAe,sJAAsJ,eAAe,8EAA8E,YAAY,4EAA4E,eAAe,0EAA0E,YAAY,wEAAwE,YAAY,wWAAwW,aAAa,oCAAoC,eAAe,oCAAoC,gBAAgB,eAAe,0CAA0C,sCAAsC,yCAAyC,gEAAgE,qEAAqE,gCAAgC,IAAI,yBAAyB,iBAAiB,qBAAqB,mBAAmB,KAAK,0BAA0B,yBAAyB,0BAA0B,2BAA2B,4BAA4B,KAAK,4BAA4B,oBAAoB,kBAAkB,mBAAmB,KAAK,2DAA2D,4DAA4D,IAAI,kEAAkE,4DAA4D,IAAI,mFAAmF,gEAAgE,8CAA8C,IAAI,kFAAkF,8DAA8D,IAAI,qHAAqH,kIAAkI,IAAI,0CAA0C,eAAe,sDAAsD,sDAAsD,sDAAsD,iBAAiB,IAAI,2DAA2D,oDAAoD,uCAAuC,IAAI,MAAM,uJAAuJ,yCAAyC,oBAAoB,6CAA6C,0FAA0F,0DAA0D,OAAO,YAAY,0FAA0F,0DAA0D,OAAO,kBAAkB,IAAI,gMAAgM,2DAA2D,0CAA0C,0CAA0C,kDAAkD,kDAAkD,oDAAoD,2CAA2C,qCAAqC,oDAAoD,IAAI,oMAAoM,yEAAyE,6CAA6C,kEAAkE,uDAAuD,qDAAqD,iEAAiE,2EAA2E,kCAAkC,+CAA+C,aAAa,kBAAkB,iDAAiD,yCAAyC,sBAAsB,0DAA0D,yDAAyD,8DAA8D,OAAO,2BAA2B,yDAAyD,4DAA4D,8DAA8D,OAAO,2BAA2B,yDAAyD,gEAAgE,8DAA8D,OAAO,2BAA2B,yDAAyD,wDAAwD,gEAAgE,OAAO,2BAA2B,0DAA0D,2DAA2D,gEAAgE,OAAO,YAAY,0DAA0D,+DAA+D,gEAAgE,OAAO,uBAAuB,sDAAsD,yDAAyD,+CAA+C,sDAAsD,IAAI,kIAAkI,sDAAsD,qCAAqC,0BAA0B,oCAAoC,qEAAqE,0BAA0B,+BAA+B,kCAAkC,2CAA2C,6CAA6C,6DAA6D,mEAAmE,6DAA6D,mEAAmE,6CAA6C,mCAAmC,IAAI,eAAe,wFAAwF,kEAAkE,eAAe,4GAA4G,sCAAsC,qCAAqC,eAAe,8LAA8L,eAAe,kHAAkH,wEAAwE,iDAAiD,eAAe,kGAAkG,eAAe,sFAAsF,MAAM,+EAA+E,mBAAmB,IAAI,8DAA8D,oEAAoE,IAAI,8DAA8D,0EAA0E,IAAI,uCAAuC,wLAAwL,IAAI,uCAAuC,yKAAyK,IAAI,uCAAuC,sEAAsE,IAAI,uCAAuC,mEAAmE,wEAAwE,wEAAwE,IAAI,0DAA0D,yDAAyD,IAAI,0DAA0D,6DAA6D,0DAA0D,+CAA+C,qDAAqD,IAAI,0DAA0D,yEAAyE,IAAI,0DAA0D,6DAA6D,mDAAmD,oDAAoD,iEAAiE,IAAI,wGAAwG,0CAA0C,4CAA4C,yDAAyD,mBAAmB,8CAA8C,iDAAiD,4BAA4B,8DAA8D,qBAAqB,IAAI,oHAAoH,yCAAyC,2CAA2C,qBAAqB,6CAA6C,0CAA0C,0CAA0C,kDAAkD,yCAAyC,IAAI,MAAM,2MAA2M,4EAA4E,2GAA2G,oGAAoG,8DAA8D,0IAA0I,iEAAiE,8CAA8C,sFAAsF,gFAAgF,uDAAuD,uFAAuF,8GAA8G,yEAAyE,gDAAgD,6DAA6D,kJAAkJ,uIAAuI,mHAAmH,2BAA2B,oHAAoH,oCAAoC,+KAA+K,6EAA6E,6CAA6C,2CAA2C,8IAA8I,0CAA0C,2BAA2B,uKAAuK,0CAA0C,uCAAuC,2BAA2B,yKAAyK,0FAA0F,uFAAuF,oGAAoG,6FAA6F,0CAA0C,sEAAsE,YAAY,wEAAwE,eAAe,2KAA2K,8EAA8E,kFAAkF,eAAe,0EAA0E,6BAA6B,uDAAuD,0CAA0C,8BAA8B,2BAA2B,uFAAuF,sEAAsE,qDAAqD,qDAAqD,sFAAsF,+EAA+E,sBAAsB,eAAe,oJAAoJ,eAAe,yFAAyF,sCAAsC,YAAY,+DAA+D,6BAA6B,sCAAsC,oDAAoD,mDAAmD,iCAAiC,6CAA6C,0CAA0C,2CAA2C,6BAA6B,qDAAqD,sCAAsC,eAAe,iCAAiC,kDAAkD,sBAAsB,QAAQ,kFAAkF,+DAA+D,2DAA2D,qEAAqE,oGAAoG,sBAAsB,0DAA0D,qBAAqB,QAAQ,gFAAgF,+DAA+D,2DAA2D,qEAAqE,oGAAoG,sBAAsB,yDAAyD,oBAAoB,QAAQ,8FAA8F,+DAA+D,2DAA2D,qEAAqE,oGAAoG,sBAAsB,0DAA0D,qBAAqB,QAAQ,wFAAwF,0HAA0H,sBAAsB,eAAe,yDAAyD,sEAAsE,0CAA0C,iEAAiE,oCAAoC,IAAI,wDAAwD,wBAAwB,oBAAoB,oBAAoB,0BAA0B,4BAA4B,4BAA4B,QAAQ,mEAAmE,iKAAiK,oDAAoD,4DAA4D,oCAAoC,OAAO,6DAA6D,uBAAuB,oBAAoB,wBAAwB,qBAAqB,oBAAoB,0BAA0B,4BAA4B,4BAA4B,gCAAgC,+BAA+B,QAAQ,yDAAyD,+IAA+I,gEAAgE,sDAAsD,iDAAiD,8CAA8C,+HAA+H,oEAAoE,OAAO,2DAA2D,uBAAuB,wBAAwB,oBAAoB,wBAAwB,qBAAqB,uBAAuB,2BAA2B,oBAAoB,0BAA0B,4BAA4B,4BAA4B,QAAQ,sDAAsD,6IAA6I,+DAA+D,sDAAsD,iDAAiD,4EAA4E,8CAA8C,gGAAgG,gDAAgD,6IAA6I,uCAAuC,WAAW,MAAM,4CAA4C,wCAAwC,UAAU,OAAO,oEAAoE,oBAAoB,uBAAuB,wBAAwB,yBAAyB,QAAQ,+BAA+B,4BAA4B,mEAAmE,iEAAiE,wBAAwB,uBAAuB,0BAA0B,QAAQ,kEAAkE,mHAAmH,mEAAmE,qDAAqD,+FAA+F,uEAAuE,0CAA0C,OAAO,wKAAwK,qFAAqF,+GAA+G,gIAAgI,yGAAyG,uFAAuF,4HAA4H,8DAA8D,yDAAyD,sEAAsE,OAAO,oGAAoG,wDAAwD,kHAAkH,iEAAiE,OAAO,iJAAiJ,kHAAkH,2GAA2G,yFAAyF,6FAA6F,oHAAoH,mIAAmI,4GAA4G,uFAAuF,iIAAiI,mHAAmH,uEAAuE,yFAAyF,mFAAmF,0HAA0H,mGAAmG,uFAAuF,2JAA2J,4IAA4I,qHAAqH,uFAAuF,iEAAiE,OAAO,eAAe,gEAAgE,4CAA4C,qCAAqC,0CAA0C,gDAAgD,MAAM,oEAAoE,iDAAiD,uCAAuC,0BAA0B,2BAA2B,gCAAgC,+BAA+B,KAAK,mLAAmL,gIAAgI,4FAA4F,qDAAqD,6EAA6E,6GAA6G,sLAAsL,IAAI,kLAAkL,mGAAmG,IAAI,6KAA6K,iEAAiE,wEAAwE,oEAAoE,gIAAgI,6IAA6I,iDAAiD,wEAAwE,eAAe,qEAAqE,0BAA0B,gCAAgC,2BAA2B,+CAA+C,kCAAkC,iBAAiB,uKAAuK,+IAA+I,IAAI,4NAA4N,uCAAuC,yCAAyC,2CAA2C,gDAAgD,kDAAkD,oDAAoD,+CAA+C,sDAAsD,8BAA8B,6DAA6D,0DAA0D,6DAA6D,6DAA6D,wDAAwD,gDAAgD,0CAA0C,0IAA0I,mJAAmJ,+IAA+I,OAAO,wLAAwL,8EAA8E,kDAAkD,iEAAiE,8IAA8I,6CAA6C,wLAAwL,0HAA0H,gNAAgN,gBAAgB,8KAA8K,mGAAmG,IAAI,8MAA8M,kGAAkG,6BAA6B,4GAA4G,6CAA6C,uLAAuL,wNAAwN,gBAAgB,mlBAAmlB,oHAAoH,IAAI,MAAM,2DAA2D,uCAAuC,4BAA4B,iDAAiD,6BAA6B,mFAAmF,uBAAuB,sBAAsB,QAAQ,uCAAuC,4EAA4E,2TAA2T,qFAAqF,OAAO,yFAAyF,uBAAuB,qBAAqB,QAAQ,qCAAqC,0EAA0E,uPAAuP,qFAAqF,OAAO,sGAAsG,uBAAuB,oBAAoB,QAAQ,mDAAmD,wFAAwF,iSAAiS,qFAAqF,OAAO,+GAA+G,uBAAuB,0BAA0B,QAAQ,6CAA6C,iFAAiF,OAAO,oHAAoH,gHAAgH,+EAA+E,yDAAyD,uEAAuE,qBAAqB,QAAQ,0FAA0F,UAAU,0KAA0K,uFAAuF,uLAAuL,4JAA4J,yDAAyD,yGAAyG,eAAe,oKAAoK,YAAY,gGAAgG,kEAAkE,2BAA2B,8HAA8H,8CAA8C,YAAY,iIAAiI,sGAAsG,wCAAwC,2BAA2B,uFAAuF,kDAAkD,iCAAiC,eAAe,0EAA0E,eAAe,yIAAyI,2CAA2C,mDAAmD,eAAe,sFAAsF,4BAA4B,eAAe,sEAAsE,qFAAqF,0CAA0C,eAAe,qGAAqG,YAAY,qIAAqI,6EAA6E,6EAA6E,6EAA6E,eAAe,0IAA0I,0DAA0D,wBAAwB,sIAAsI,8EAA8E,8EAA8E,8EAA8E,4GAA4G,8EAA8E,8EAA8E,8EAA8E,2BAA2B,mJAAmJ,mGAAmG,mDAAmD,iDAAiD,4FAA4F,uGAAuG,sGAAsG,eAAe,4FAA4F,+BAA+B,8DAA8D,mFAAmF,mFAAmF,mCAAmC,mCAAmC,uDAAuD,wDAAwD,yCAAyC,iEAAiE,yCAAyC,oCAAoC,wCAAwC,OAAO,eAAe,oEAAoE,6CAA6C,IAAI,gDAAgD,iCAAiC,IAAI,yCAAyC,0CAA0C,2EAA2E,wEAAwE,uCAAuC,6CAA6C,mDAAmD,mCAAmC,0BAA0B,IAAI,+CAA+C,qCAAqC,IAAI,oGAAoG,+CAA+C,IAAI,0GAA0G,iDAAiD,IAAI,mGAAmG,mEAAmE,IAAI,sGAAsG,kEAAkE,IAAI,MAAM,8GAA8G,eAAe,0FAA0F,+CAA+C,MAAM,+GAA+G,eAAe,kGAAkG,uDAAuD,mFAAmF,kGAAkG,yCAAyC,OAAO,eAAe,sEAAsE,qFAAqF,0CAA0C,eAAe,qGAAqG,YAAY,wJAAwJ,gEAAgE,qGAAqG,0DAA0D,wGAAwG,4DAA4D,sFAAsF,8EAA8E,OAAO,wFAAwF,8CAA8C,6CAA6C,2DAA2D,4FAA4F,4FAA4F,4FAA4F,4FAA4F,2CAA2C,sCAAsC,sCAAsC,oCAAoC,kBAAkB,OAAO,0HAA0H,4BAA4B,0CAA0C,qCAAqC,+HAA+H,8CAA8C,yEAAyE,kDAAkD,6BAA6B,mGAAmG,qDAAqD,qDAAqD,qDAAqD,qDAAqD,+3BAA+3B,0GAA0G,qDAAqD,qDAAqD,qDAAqD,qDAAqD,iiCAAiiC,gGAAgG,yBAAyB,uBAAuB,OAAO,iDAAiD,8BAA8B,wEAAwE,6BAA6B,uDAAuD,4BAA4B,+CAA+C,8CAA8C,qCAAqC,gEAAgE,WAAW,iCAAiC,sCAAsC,iDAAiD,WAAW,iCAAiC,sCAAsC,+CAA+C,yCAAyC,UAAU,mEAAmE,OAAO,8KAA8K,6EAA6E,gDAAgD,8GAA8G,uBAAuB,kDAAkD,sJAAsJ,i3BAAi3B,kGAAkG,sBAAsB,eAAe,oJAAoJ,gEAAgE,mGAAmG,0DAA0D,sGAAsG,4DAA4D,2BAA2B,sGAAsG,oBAAoB,QAAQ,qFAAqF,OAAO,gEAAgE,qBAAqB,QAAQ,uEAAuE,OAAO,iEAAiE,sBAAsB,QAAQ,yEAAyE,OAAO,2BAA2B,8DAA8D,yBAAyB,8FAA8F,uBAAuB,oBAAoB,QAAQ,mDAAmD,4NAA4N,OAAO,mEAAmE,uBAAuB,qBAAqB,QAAQ,qCAAqC,kLAAkL,OAAO,sEAAsE,uBAAuB,sBAAsB,QAAQ,uCAAuC,sPAAsP,OAAO,4CAA4C,IAAI,MAAM,oGAAoG,mDAAmD,mDAAmD,mDAAmD,YAAY,oFAAoF,qCAAqC,gEAAgE,qCAAqC,iDAAiD,8BAA8B,yDAAyD,4DAA4D,sDAAsD,sDAAsD,iCAAiC,4EAA4E,4EAA4E,4EAA4E,4EAA4E,+CAA+C,wBAAwB,UAAU,2DAA2D,iDAAiD,+CAA+C,wBAAwB,UAAU,2BAA2B,+GAA+G,iCAAiC,sDAAsD,sDAAsD,sDAAsD,sDAAsD,wDAAwD,eAAe,uFAAuF,4CAA4C,4CAA4C,4CAA4C,4CAA4C,gEAAgE,wEAAwE,eAAe,0DAA0D,kFAAkF,yCAAyC,qCAAqC,YAAY,kGAAkG,YAAY,sHAAsH,eAAe,oJAAoJ,uCAAuC,yCAAyC,yCAAyC,IAAI,2CAA2C,mCAAmC,yDAAyD,IAAI,gNAAgN,mCAAmC,uGAAuG,IAAI,kDAAkD,mCAAmC,gDAAgD,8GAA8G,IAAI,MAAM,uRAAuR,YAAY,qRAAqR,+BAA+B,eAAe,wSAAwS,YAAY,2GAA2G,YAAY,0GAA0G,wBAAwB,YAAY,6FAA6F,YAAY,6KAA6K,eAAe,kDAAkD,uBAAuB,yBAAyB,+BAA+B,gBAAgB,+FAA+F,gCAAgC,IAAI,MAAM,oDAAoD,oCAAoC,mEAAmE,gGAAgG,IAAI,MAAM,8EAA8E,qPAAqP,+EAA+E,iEAAiE,kPAAkP,2FAA2F,gBAAgB,MAAM,oRAAoR,2cAA2c,MAAM,kFAAkF,8BAA8B,6BAA6B,+BAA+B,sMAAsM,+EAA+E,kKAAkK,sEAAsE,8BAA8B,6CAA6C,IAAI,MAAM,+EAA+E,yNAAyN,6eAA6e,IAAI,MAAM,wDAAwD,+BAA+B,oCAAoC,mDAAmD,oBAAoB,kFAAkF,2EAA2E,sDAAsD,IAAI,MAAM,wDAAwD,oCAAoC,mEAAmE,gEAAgE,MAAM,mDAAmD,yBAAyB,0BAA0B,2BAA2B,+BAA+B,sLAAsL,kGAAkG,iBAAiB,OAAO,uCAAuC,mDAAmD,2GAA2G,2DAA2D,sJAAsJ,MAAM,kDAAkD,gCAAgC,+BAA+B,8KAA8K,wEAAwE,gEAAgE,kDAAkD,yGAAyG,MAAM,kDAAkD,yBAAyB,iDAAiD,6cAA6c,4FAA4F,sTAAsT,wHAAwH,kEAAkE,oGAAoG,0DAA0D,2FAA2F,sJAAsJ,MAAM,wWAAwW,wkBAAwkB,MAAM,oDAAoD,yBAAyB,yBAAyB,4BAA4B,oDAAoD,qqBAAqqB,4FAA4F,2GAA2G,4CAA4C,sUAAsU,mHAAmH,+GAA+G,+DAA+D,6GAA6G,gJAAgJ,2FAA2F,yLAAyL,MAAM,0EAA0E,oDAAoD,saAAsa,4mBAA4mB,MAAM,kEAAkE,yBAAyB,yBAAyB,2BAA2B,yBAAyB,6wBAA6wB,4FAA4F,2GAA2G,4CAA4C,wiBAAwiB,2FAA2F,yLAAyL,MAAM,wEAAwE,iDAAiD,maAAma,oUAAoU,gSAAgS,8HAA8H,MAAM,wEAAwE,yBAAyB,2BAA2B,2BAA2B,yBAAyB,iDAAiD,uCAAuC,uCAAuC,iDAAiD,o0BAAo0B,4FAA4F,2GAA2G,4CAA4C,klBAAklB,2DAA2D,yLAAyL,MAAM,8EAA8E,iDAAiD,mYAAmY,oUAAoU,gSAAgS,gGAAgG,MAAM,iEAAiE,oHAAoH,0DAA0D,2LAA2L,qIAAqI,IAAI,MAAM,4JAA4J,0DAA0D,0MAA0M,4QAA4Q,4UAA4U,aAAa,MAAM,+CAA+C,yBAAyB,wRAAwR,gFAAgF,mDAAmD,oLAAoL,2DAA2D,sJAAsJ,MAAM,6CAA6C,uBAAuB,iNAAiN,mLAAmL,wCAAwC,sLAAsL,MAAM,6CAA6C,yBAAyB,+MAA+M,wEAAwE,iCAAiC,MAAM,uGAAuG,4JAA4J,MAAM,yBAAyB,suJAAsuJ,oLAAoL,gBAAgB,oVAAoV,mBAAmB,qSAAqS,wBAAwB,8BAA8B,WAAW,8HAA8H,iBAAiB,2aAA2a,wBAAwB,8BAA8B,yBAAyB,8BAA8B,0BAA0B,WAAW,WAAW,0HAA0H,oBAAoB,6aAA6a,wBAAwB,8BAA8B,0BAA0B,YAAY,0BAA0B,YAAY,gCAAgC,WAAW,uBAAuB,gIAAgI,kBAAkB,oNAAoN,kBAAkB,4GAA4G,qBAAqB,UAAU,yBAAyB,UAAU,0BAA0B,UAAU,WAAW,4HAA4H,iBAAiB,8NAA8N,kBAAkB,sLAAsL,uBAAuB,YAAY,WAAW,oHAAoH,gNAAgN,qBAAqB,mBAAmB,aAAa,oBAAoB,YAAY,sBAAsB,YAAY,SAAS,qGAAqG,oBAAoB,qBAAqB,uBAAuB,aAAa,UAAU,6GAA6G,wBAAwB,wHAAwH,iCAAiC,sBAAsB,6BAA6B,UAAU,4BAA4B,aAAa,WAAW,gIAAgI,kBAAkB,4GAA4G,qBAAqB,6BAA6B,wBAAwB,YAAY,WAAW,qHAAqH,QAAQ,4BAA4B,qFAAqF,uBAAuB,UAAU,iCAAiC,UAAU,SAAS,yHAAyH,0FAA0F,uFAAuF,qFAAqF,OAAO,sCAAsC,oCAAoC,+BAA+B,6BAA6B,sBAAsB,SAAS,6CAA6C,2BAA2B,+CAA+C,QAAQ,QAAQ,8CAA8C,WAAW,sBAAsB,SAAS,4CAA4C,iCAAiC,gEAAgE,iEAAiE,kDAAkD,kDAAkD,wBAAwB,YAAY,SAAS,+BAA+B,qDAAqD,SAAS,iCAAiC,mCAAmC,iCAAiC,sBAAsB,SAAS,iCAAiC,+CAA+C,6CAA6C,sBAAsB,SAAS,+BAA+B,0MAA0M,SAAS,iDAAiD,uDAAuD,mHAAmH,SAAS,+CAA+C,uDAAuD,6FAA6F,SAAS,4CAA4C,gCAAgC,8BAA8B,sBAAsB,SAAS,8CAA8C,iCAAiC,+BAA+B,sBAAsB,SAAS,8CAA8C,yCAAyC,qCAAqC,sBAAsB,SAAS,4CAA4C,sIAAsI,SAAS,wCAAwC,mIAAmI,SAAS,2DAA2D,8JAA8J,uKAAuK,SAAS,0CAA0C,6MAA6M,SAAS,yDAAyD,uDAAuD,gEAAgE,SAAS,uCAAuC,iCAAiC,oDAAoD,4EAA4E,oDAAoD,YAAY,SAAS,wCAAwC,kCAAkC,gCAAgC,sBAAsB,SAAS,kCAAkC,kCAAkC,gCAAgC,sBAAsB,SAAS,yCAAyC,iCAAiC,+BAA+B,sBAAsB,SAAS,mCAAmC,0EAA0E,SAAS,QAAQ,EAAE,qMAAqM,wCAAwC,gDAAgD,0CAA0C,yBAAyB,uJAAuJ,uFAAuF,+DAA+D,0CAA0C,yDAAyD,mEAAmE,kEAAkE,wEAAwE,gEAAgE,8CAA8C,0DAA0D,6FAA6F,+EAA+E,+EAA+E,6EAA6E,6EAA6E,+DAA+D,+FAA+F,+EAA+E,+EAA+E,6EAA6E,6EAA6E,oBAAoB,sEAAsE,6CAA6C,kCAAkC,sCAAsC,gDAAgD,yCAAyC,iCAAiC,kCAAkC,yCAAyC,8BAA8B,4BAA4B,uCAAuC,2CAA2C,mFAAmF,6EAA6E,6EAA6E,6EAA6E,6EAA6E,6EAA6E,6EAA6E,6EAA6E,6EAA6E,6DAA6D,2DAA2D,2DAA2D,2DAA2D,yFAAyF,uFAAuF,oBAAoB,uGAAuG,kBAAkB,qGAAqG,uCAAuC,qCAAqC,kCAAkC,kCAAkC,yCAAyC,8BAA8B,uEAAuE,+DAA+D,6CAA6C,6BAA6B,0DAA0D,2CAA2C,MAAM,0DAA0D,sDAAsD,0CAA0C,6CAA6C,oBAAoB,kBAAkB,wCAAwC,4CAA4C,wBAAwB,2HAA2H,sBAAsB,ihBAAihB,SAAS,yQAAyQ,4CAA4C,2CAA2C,iJAAiJ,6FAA6F,2GAA2G,qCAAqC,sDAAsD,gGAAgG,wCAAwC,mBAAmB,WAAW,sCAAsC,iCAAiC,mDAAmD,+CAA+C,wCAAwC,wLAAwL,wCAAwC,yDAAyD,kFAAkF,8EAA8E,kEAAkE,wCAAwC,6CAA6C,8CAA8C,OAAO,QAAQ,mCAAmC,8CAA8C,8EAA8E,qIAAqI,mEAAmE,+DAA+D,2FAA2F,mNAAmN,mHAAmH,uGAAuG,kGAAkG,qDAAqD,+CAA+C,4DAA4D,qHAAqH,wFAAwF,6DAA6D,0GAA0G,wCAAwC,0CAA0C,uEAAuE,+FAA+F,iEAAiE,sHAAsH,wFAAwF,2CAA2C,iDAAiD,4DAA4D,qEAAqE,oGAAoG,iDAAiD,oDAAoD,gBAAgB,MAAM,yCAAyC,eAAe,mFAAmF,qCAAqC,6DAA6D,QAAQ,QAAQ,mDAAmD,uEAAuE,8CAA8C,4CAA4C,4CAA4C,iEAAiE,6CAA6C,+BAA+B,gHAAgH,iEAAiE,mEAAmE,mEAAmE,+FAA+F,+GAA+G,6DAA6D,2EAA2E,iBAAiB,eAAe,aAAa,WAAW,8DAA8D,sCAAsC,4CAA4C,wBAAwB,UAAU,0CAA0C,2CAA2C,qEAAqE,+DAA+D,uEAAuE,KAAK,4EAA4E,sEAAsE,6CAA6C,yCAAyC,qDAAqD,iDAAiD,oCAAoC,yBAAyB,SAAS,OAAO,yKAAyK,4GAA4G,gCAAgC,OAAO,mEAAmE,wDAAwD,sMAAsM,wCAAwC,wCAAwC,oBAAoB,2EAA2E,4CAA4C,sCAAsC,yBAAyB,uKAAuK,uFAAuF,2CAA2C,0CAA0C,yDAAyD,mEAAmE,kEAAkE,wEAAwE,oCAAoC,wBAAwB,6HAA6H,sBAAsB,qiCAAqiC,4FAA4F,yBAAyB,0BAA0B,kDAAkD,oCAAoC,uCAAuC,gDAAgD,SAAS,2DAA2D,6CAA6C,6DAA6D,mBAAmB,WAAW,sCAAsC,iCAAiC,qDAAqD,+CAA+C,wCAAwC,wCAAwC,iCAAiC,yDAAyD,oFAAoF,8EAA8E,kEAAkE,oGAAoG,6CAA6C,wCAAwC,6BAA6B,6BAA6B,4BAA4B,sBAAsB,qFAAqF,8BAA8B,yDAAyD,qDAAqD,kDAAkD,2BAA2B,6BAA6B,cAAc,2BAA2B,+DAA+D,kDAAkD,2BAA2B,6BAA6B,aAAa,YAAY,MAAM,gDAAgD,yBAAyB,2BAA2B,WAAW,uFAAuF,OAAO,QAAQ,sCAAsC,qGAAqG,6DAA6D,WAAW,4CAA4C,wDAAwD,+CAA+C,OAAO,QAAQ,sCAAsC,yCAAyC,uDAAuD,6FAA6F,mEAAmE,kGAAkG,wFAAwF,uCAAuC,qCAAqC,4BAA4B,8CAA8C,qCAAqC,aAAa,2CAA2C,wDAAwD,iCAAiC,aAAa,0CAA0C,8FAA8F,2FAA2F,cAAc,MAAM,sDAAsD,mDAAmD,aAAa,+DAA+D,+FAA+F,iEAAiE,iDAAiD,2NAA2N,4DAA4D,6DAA6D,6DAA6D,gEAAgE,qEAAqE,4FAA4F,WAAW,8DAA8D,wBAAwB,UAAU,kCAAkC,2CAA2C,iEAAiE,mEAAmE,sGAAsG,kGAAkG,2CAA2C,oCAAoC,gCAAgC,mCAAmC,kCAAkC,uCAAuC,+BAA+B,gCAAgC,oCAAoC,4BAA4B,+CAA+C,yDAAyD,sCAAsC,6GAA6G,6GAA6G,iCAAiC,2EAA2E,gDAAgD,6DAA6D,2CAA2C,gBAAgB,6BAA6B,wGAAwG,wFAAwF,mCAAmC,mCAAmC,mCAAmC,mCAAmC,sCAAsC,mCAAmC,kCAAkC,qCAAqC,gCAAgC,oCAAoC,4BAA4B,sDAAsD,iFAAiF,2DAA2D,qCAAqC,yCAAyC,wCAAwC,yEAAyE,qBAAqB,MAAM,iDAAiD,8FAA8F,kEAAkE,oBAAoB,mFAAmF,kBAAkB,gBAAgB,6BAA6B,2CAA2C,2CAA2C,mDAAmD,mDAAmD,oCAAoC,yBAAyB,SAAS,4CAA4C,kDAAkD,iDAAiD,YAAY,yBAAyB,6BAA6B,YAAY,MAAM,+BAA+B,WAAW,SAAS,OAAO,sIAAsI,2BAA2B,6CAA6C,uBAAuB,EAAE,yCAAyC,uBAAuB,6BAA6B,wBAAwB,yBAAyB,uCAAuC,4BAA4B,+BAA+B,oCAAoC,gFAAgF,+BAA+B,uCAAuC,6CAA6C,uCAAuC,gCAAgC,gCAAgC,qCAAqC,wCAAwC,4BAA4B,6BAA6B,mCAAmC,oCAAoC,+BAA+B,+BAA+B,+BAA+B,iGAAiG,mCAAmC,kCAAkC,+BAA+B,2BAA2B,sCAAsC,2BAA2B,0HAA0H,2BAA2B,gCAAgC,OAAO,uFAAuF,8FAA8F,yCAAyC,6CAA6C,qCAAqC,yCAAyC,2CAA2C,0FAA0F,qBAAqB,aAAa,kHAAkH,0HAA0H,2EAA2E,qBAAqB,aAAa,2CAA2C,+CAA+C,iHAAiH,qBAAqB,aAAa,yDAAyD,2CAA2C,cAAc,8FAA8F,4CAA4C,cAAc,gCAAgC,8HAA8H,cAAc,MAAM,qCAAqC,aAAa,WAAW,SAAS,oCAAoC,0EAA0E,yBAAyB,oBAAoB,wBAAwB,uBAAuB,YAAY,WAAW,sBAAsB,qBAAqB,yGAAyG,UAAU,0EAA0E,8BAA8B,wDAAwD,mFAAmF,8EAA8E,4EAA4E,+FAA+F,4FAA4F,+FAA+F,4EAA4E,4EAA4E,uGAAuG,wFAAwF,0GAA0G,0GAA0G,uDAAuD,4DAA4D,0CAA0C,WAAW,2DAA2D,gEAAgE,wDAAwD,WAAW,uEAAuE,4EAA4E,0DAA0D,wDAAwD,WAAW,0HAA0H,0HAA0H,wHAAwH,sHAAsH,uDAAuD,0DAA0D,iDAAiD,iCAAiC,iEAAiE,oEAAoE,WAAW,+DAA+D,8FAA8F,gFAAgF,6EAA6E,6DAA6D,oFAAoF,8DAA8D,6EAA6E,0CAA0C,wCAAwC,0CAA0C,uGAAuG,sEAAsE,yEAAyE,sEAAsE,gEAAgE,+DAA+D,oEAAoE,kGAAkG,yEAAyE,6FAA6F,+FAA+F,kGAAkG,qEAAqE,2DAA2D,6DAA6D,oDAAoD,kCAAkC,4FAA4F,4BAA4B,sCAAsC,sCAAsC,iCAAiC,gCAAgC,aAAa,0BAA0B,WAAW,yBAAyB,6DAA6D,uDAAuD,gEAAgE,wDAAwD,WAAW,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,oCAAoC,kCAAkC,gCAAgC,oCAAoC,0CAA0C,gCAAgC,8CAA8C,gDAAgD,wCAAwC,8CAA8C,0CAA0C,wCAAwC,kDAAkD,kDAAkD,kDAAkD,4DAA4D,4CAA4C,0CAA0C,4CAA4C,8CAA8C,4CAA4C,oDAAoD,8DAA8D,4DAA4D,4CAA4C,4CAA4C,4DAA4D,0CAA0C,wCAAwC,wEAAwE,gDAAgD,wDAAwD,2EAA2E,qCAAqC,qCAAqC,qCAAqC,6BAA6B,SAAS,0DAA0D,WAAW,0CAA0C,sBAAsB,SAAS,+BAA+B,gCAAgC,kBAAkB,EAAE,SAAS,QAAQ,EAAE,qOAAqO,mVAAmV,uDAAuD,8BAA8B,wCAAwC,8CAA8C,8BAA8B,gCAAgC,wBAAwB,6BAA6B,oCAAoC,iCAAiC,gCAAgC,+BAA+B,kCAAkC,yBAAyB,0BAA0B,qCAAqC,OAAO,wEAAwE,gEAAgE,6DAA6D,8DAA8D,qDAAqD,gDAAgD,wCAAwC,8CAA8C,8BAA8B,wCAAwC,sDAAsD,wDAAwD,sDAAsD,0CAA0C,0DAA0D,oBAAoB,QAAQ,8FAA8F,mZAAmZ,0DAA0D,8BAA8B,2CAA2C,+CAA+C,4BAA4B,8BAA8B,8BAA8B,gCAAgC,wBAAwB,6BAA6B,oCAAoC,iCAAiC,gCAAgC,yBAAyB,0BAA0B,qCAAqC,OAAO,2EAA2E,sEAAsE,mEAAmE,iEAAiE,qDAAqD,gEAAgE,8CAA8C,4CAA4C,wCAAwC,8CAA8C,8BAA8B,wCAAwC,sDAAsD,wDAAwD,sDAAsD,oBAAoB,QAAQ,oJAAoJ,mGAAmG,iGAAiG,OAAO,sCAAsC,yDAAyD,+BAA+B,6BAA6B,sBAAsB,SAAS,2CAA2C,gCAAgC,8BAA8B,8BAA8B,gCAAgC,8BAA8B,8BAA8B,6CAA6C,OAAO,UAAU,+BAA+B,iCAAiC,iCAAiC,qCAAqC,mCAAmC,mCAAmC,qCAAqC,mCAAmC,mCAAmC,WAAW,2CAA2C,yCAAyC,sBAAsB,SAAS,yDAAyD,gCAAgC,8BAA8B,8BAA8B,gCAAgC,8BAA8B,8BAA8B,gDAAgD,OAAO,QAAQ,wCAAwC,sCAAsC,sCAAsC,qCAAqC,mCAAmC,mCAAmC,qCAAqC,mCAAmC,mCAAmC,WAAW,2CAA2C,yCAAyC,sBAAsB,SAAS,6CAA6C,2BAA2B,+CAA+C,QAAQ,QAAQ,8CAA8C,WAAW,sBAAsB,SAAS,4CAA4C,iCAAiC,gEAAgE,iEAAiE,oDAAoD,kDAAkD,wBAAwB,YAAY,SAAS,+CAA+C,2BAA2B,+CAA+C,SAAS,6BAA6B,qDAAqD,SAAS,iCAAiC,mCAAmC,iCAAiC,sBAAsB,SAAS,iCAAiC,4DAA4D,0DAA0D,sBAAsB,SAAS,+BAA+B,yOAAyO,SAAS,iDAAiD,uDAAuD,sHAAsH,SAAS,+CAA+C,uDAAuD,gGAAgG,SAAS,4CAA4C,gCAAgC,8BAA8B,sBAAsB,SAAS,8CAA8C,iCAAiC,+BAA+B,sBAAsB,SAAS,8CAA8C,yCAAyC,qCAAqC,sBAAsB,SAAS,sCAAsC,uMAAuM,iCAAiC,qCAAqC,yCAAyC,2CAA2C,0CAA0C,iDAAiD,kDAAkD,OAAO,QAAQ,2CAA2C,oDAAoD,4CAA4C,iBAAiB,gBAAgB,uCAAuC,6DAA6D,gDAAgD,oDAAoD,OAAO,QAAQ,4FAA4F,8CAA8C,mBAAmB,iBAAiB,eAAe,aAAa,WAAW,oDAAoD,yBAAyB,6CAA6C,wCAAwC,wBAAwB,YAAY,SAAS,8CAA8C,+LAA+L,SAAS,wCAAwC,kMAAkM,SAAS,2DAA2D,8JAA8J,wOAAwO,SAAS,0CAA0C,yQAAyQ,SAAS,0CAA0C,2CAA2C,sDAAsD,gIAAgI,uLAAuL,YAAY,UAAU,iDAAiD,sMAAsM,qCAAqC,8CAA8C,4CAA4C,YAAY,MAAM,8CAA8C,4CAA4C,WAAW,qCAAqC,+CAA+C,6CAA6C,YAAY,MAAM,+CAA+C,6CAA6C,WAAW,qCAAqC,+CAA+C,6CAA6C,YAAY,MAAM,+CAA+C,6CAA6C,WAAW,oEAAoE,SAAS,yDAAyD,uDAAuD,gEAAgE,SAAS,uCAAuC,iCAAiC,oDAAoD,4EAA4E,oDAAoD,YAAY,SAAS,2CAA2C,iCAAiC,+DAA+D,wDAAwD,4CAA4C,8DAA8D,0BAA0B,YAAY,SAAS,wCAAwC,kCAAkC,gCAAgC,iPAAiP,sBAAsB,SAAS,kCAAkC,kCAAkC,gCAAgC,sBAAsB,SAAS,oCAAoC,iOAAiO,kDAAkD,kGAAkG,8KAA8K,8FAA8F,8FAA8F,8FAA8F,8FAA8F,8FAA8F,8FAA8F,6FAA6F,iDAAiD,wBAAwB,YAAY,SAAS,2CAA2C,iCAAiC,+BAA+B,sBAAsB,SAAS,mCAAmC,0EAA0E,SAAS,QAAQ,EAAE,4IAA4I,wEAAwE,0DAA0D,OAAO,wCAAwC,0CAA0C,qCAAqC,6BAA6B,sBAAsB,SAAS,qCAAqC,+BAA+B,mEAAmE,qCAAqC,iDAAiD,4CAA4C,cAAc,MAAM,8DAA8D,aAAa,gCAAgC,iDAAiD,QAAQ,QAAQ,6FAA6F,aAAa,mDAAmD,wBAAwB,YAAY,SAAS,+BAA+B,qDAAqD,SAAS,oCAAoC,4CAA4C,oCAAoC,sBAAsB,SAAS,6BAA6B,sCAAsC,SAAS,4CAA4C,6FAA6F,SAAS,8CAA8C,mEAAmE,SAAS,gDAAgD,sDAAsD,6FAA6F,SAAS,0CAA0C,8CAA8C,SAAS,8CAA8C,iFAAiF,SAAS,yDAAyD,qEAAqE,uDAAuD,+BAA+B,gEAAgE,kDAAkD,kEAAkE,WAAW,wBAAwB,SAAS,sDAAsD,iDAAiD,8CAA8C,0CAA0C,qBAAqB,SAAS,4CAA4C,6CAA6C,+DAA+D,sBAAsB,SAAS,yCAAyC,oCAAoC,sBAAsB,SAAS,sCAAsC,0FAA0F,SAAS,QAAQ,EAAE,mGAAmG,8HAA8H,gEAAgE,OAAO,uCAAuC,4CAA4C,qCAAqC,iCAAiC,sBAAsB,SAAS,iDAAiD,qCAAqC,0BAA0B,sBAAsB,SAAS,oEAAoE,qCAAqC,mDAAmD,sBAAsB,SAAS,6CAA6C,iCAAiC,+BAA+B,4DAA4D,0FAA0F,kJAAkJ,wBAAwB,YAAY,SAAS,+BAA+B,qDAAqD,SAAS,mCAAmC,2CAA2C,uCAAuC,sBAAsB,SAAS,iCAAiC,wIAAwI,0DAA0D,6CAA6C,sBAAsB,SAAS,8BAA8B,+BAA+B,6BAA6B,sBAAsB,SAAS,8CAA8C,0DAA0D,SAAS,gDAAgD,uEAAuE,SAAS,2DAA2D,uDAAuD,2GAA2G,SAAS,qCAAqC,iCAAiC,iEAAiE,yDAAyD,6CAA6C,2DAA2D,sCAAsC,6GAA6G,iDAAiD,eAAe,uGAAuG,aAAa,sFAAsF,mCAAmC,+BAA+B,aAAa,kFAAkF,YAAY,SAAS,8CAA8C,mLAAmL,uDAAuD,sFAAsF,SAAS,0CAA0C,6CAA6C,SAAS,gDAAgD,gDAAgD,SAAS,qDAAqD,uDAAuD,8EAA8E,SAAS,oCAAoC,iCAAiC,+BAA+B,wEAAwE,oFAAoF,iFAAiF,8EAA8E,2DAA2D,wBAAwB,YAAY,SAAS,2CAA2C,qDAAqD,sBAAsB,SAAS,qCAAqC,4FAA4F,SAAS,QAAQ,EAAE,wMAAwM,kUAAkU,OAAO,yCAAyC,kDAAkD,mCAAmC,iCAAiC,+BAA+B,+BAA+B,+BAA+B,+BAA+B,+BAA+B,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,qCAAqC,mCAAmC,2BAA2B,OAAO,QAAQ,oDAAoD,WAAW,sBAAsB,SAAS,wCAAwC,mCAAmC,4BAA4B,uEAAuE,uEAAuE,2EAA2E,+EAA+E,iGAAiG,+FAA+F,+FAA+F,+FAA+F,gGAAgG,gGAAgG,sBAAsB,SAAS,wCAAwC,oCAAoC,sDAAsD,2CAA2C,gGAAgG,kGAAkG,mDAAmD,YAAY,SAAS,0CAA0C,oCAAoC,sDAAsD,yCAAyC,6CAA6C,oDAAoD,mDAAmD,YAAY,SAAS,kDAAkD,mCAAmC,mCAAmC,wCAAwC,2BAA2B,OAAO,QAAQ,iEAAiE,yCAAyC,2BAA2B,aAAa,WAAW,sBAAsB,SAAS,qCAAqC,8DAA8D,gDAAgD,qCAAqC,6BAA6B,OAAO,QAAQ,sCAAsC,gEAAgE,8DAA8D,8DAA8D,8DAA8D,8DAA8D,8DAA8D,mDAAmD,iDAAiD,8FAA8F,6BAA6B,eAAe,aAAa,wBAAwB,YAAY,SAAS,8CAA8C,mCAAmC,2BAA2B,OAAO,QAAQ,6DAA6D,2BAA2B,aAAa,WAAW,sBAAsB,SAAS,QAAQ,EAAE,mLAAmL,2jBAA2jB,yMAAyM,+LAA+L,8IAA8I,wCAAwC,iCAAiC,QAAQ,wDAAwD,sDAAsD,sDAAsD,4HAA4H,EAAE,+CAA+C,wEAAwE,iFAAiF,EAAE,qDAAqD,SAAS,mCAAmC,6BAA6B,+BAA+B,+BAA+B,iCAAiC,uCAAuC,oCAAoC,0DAA0D,gDAAgD,gFAAgF,4CAA4C,8FAA8F,qCAAqC,4EAA4E,oDAAoD,6CAA6C,uCAAuC,qDAAqD,+CAA+C,QAAQ,QAAQ,oCAAoC,oCAAoC,yDAAyD,yCAAyC,+EAA+E,qBAAqB,aAAa,6CAA6C,kDAAkD,kDAAkD,iCAAiC,6CAA6C,4CAA4C,ygBAAygB,gGAAgG,0GAA0G,sGAAsG,mGAAmG,+FAA+F,sCAAsC,oCAAoC,aAAa,wCAAwC,2BAA2B,yEAAyE,6FAA6F,kEAAkE,oDAAoD,aAAa,6CAA6C,qCAAqC,aAAa,uCAAuC,2CAA2C,2EAA2E,4DAA4D,iCAAiC,4BAA4B,yQAAyQ,cAAc,MAAM,4BAA4B,4EAA4E,+CAA+C,6CAA6C,sNAAsN,qEAAqE,qEAAqE,aAAa,mDAAmD,4BAA4B,iJAAiJ,kBAAkB,WAAW,mCAAmC,0DAA0D,wDAAwD,sDAAsD,iDAAiD,+CAA+C,2DAA2D,8CAA8C,eAAe,sKAAsK,wDAAwD,8HAA8H,aAAa,WAAW,oCAAoC,UAAU,4HAA4H,yCAAyC,4BAA4B,iDAAiD,wDAAwD,+BAA+B,kDAAkD,yDAAyD,WAAW,mCAAmC,oCAAoC,0CAA0C,4DAA4D,4IAA4I,gBAAgB,6CAA6C,wFAAwF,eAAe,aAAa,wEAAwE,qHAAqH,aAAa,wEAAwE,iCAAiC,6DAA6D,2DAA2D,sDAAsD,YAAY,MAAM,oCAAoC,WAAW,gJAAgJ,oKAAoK,6DAA6D,sDAAsD,uCAAuC,yDAAyD,aAAa,6DAA6D,iDAAiD,8CAA8C,yDAAyD,aAAa,oCAAoC,WAAW,4CAA4C,8CAA8C,mCAAmC,gEAAgE,6BAA6B,WAAW,2CAA2C,sDAAsD,yDAAyD,WAAW,6BAA6B,oDAAoD,wDAAwD,4DAA4D,kEAAkE,8CAA8C,gEAAgE,gEAAgE,iDAAiD,+CAA+C,WAAW,wBAAwB,SAAS,6EAA6E,iDAAiD,4DAA4D,mFAAmF,2GAA2G,6GAA6G,uDAAuD,2CAA2C,gDAAgD,6CAA6C,qDAAqD,QAAQ,QAAQ,0CAA0C,oEAAoE,iEAAiE,0JAA0J,6GAA6G,mBAAmB,iBAAiB,gBAAgB,8BAA8B,iJAAiJ,wGAAwG,eAAe,aAAa,WAAW,yCAAyC,gDAAgD,OAAO,QAAQ,8EAA8E,WAAW,SAAS,OAAO,gGAAgG,yBAAyB,wDAAwD,sCAAsC,yEAAyE,yCAAyC,8CAA8C,kDAAkD,uCAAuC,8BAA8B,gDAAgD,4BAA4B,YAAY,2CAA2C,mGAAmG,YAAY,0CAA0C,qCAAqC,YAAY,yCAAyC,4BAA4B,YAAY,0CAA0C,mCAAmC,YAAY,yCAAyC,0BAA0B,YAAY,wCAAwC,2BAA2B,YAAY,yCAAyC,oCAAoC,WAAW,kBAAkB,+IAA+I,SAAS,gEAAgE,sCAAsC,gDAAgD,8CAA8C,8CAA8C,+DAA+D,YAAY,uCAAuC,2FAA2F,YAAY,qCAAqC,uMAAuM,YAAY,MAAM,kLAAkL,qCAAqC,yBAAyB,SAAS,6CAA6C,mFAAmF,2CAA2C,SAAS,sCAAsC,mFAAmF,+CAA+C,uBAAuB,2CAA2C,6CAA6C,WAAW,SAAS,kDAAkD,mFAAmF,+CAA+C,qCAAqC,8EAA8E,YAAY,8CAA8C,+DAA+D,6CAA6C,WAAW,SAAS,gBAAgB,0EAA0E,OAAO,qMAAqM,yBAAyB,uBAAuB,uBAAuB,gDAAgD,OAAO,0EAA0E,iCAAiC,iDAAiD,YAAY,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,aAAa,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,aAAa,4BAA4B,2BAA2B,WAAW,oCAAoC,4BAA4B,kCAAkC,WAAW,SAAS,iBAAiB,4BAA4B,+BAA+B,WAAW,oCAAoC,gCAAgC,kCAAkC,WAAW,SAAS,QAAQ,EAAE,uCAAuC,gEAAgE,sBAAsB,oBAAoB,oBAAoB,2CAA2C,kCAAkC,sBAAsB,SAAS,6BAA6B,gFAAgF,SAAS,mCAAmC,6BAA6B,2BAA2B,2BAA2B,mCAAmC,kCAAkC,sBAAsB,SAAS,+DAA+D,kCAAkC,+GAA+G,wDAAwD,wDAAwD,yDAAyD,uCAAuC,kCAAkC,wDAAwD,8CAA8C,iDAAiD,+CAA+C,cAAc,MAAM,+CAA+C,wBAAwB,aAAa,YAAY,6BAA6B,0DAA0D,8CAA8C,+CAA+C,6CAA6C,cAAc,MAAM,iDAAiD,wBAAwB,aAAa,YAAY,6BAA6B,wDAAwD,8CAA8C,iDAAiD,+CAA+C,cAAc,MAAM,0BAA0B,6CAA6C,aAAa,YAAY,6BAA6B,0DAA0D,8CAA8C,+CAA+C,6CAA6C,cAAc,MAAM,0BAA0B,+CAA+C,aAAa,YAAY,6BAA6B,wDAAwD,8CAA8C,iDAAiD,+CAA+C,cAAc,MAAM,0BAA0B,6CAA6C,aAAa,YAAY,6BAA6B,0DAA0D,8CAA8C,+CAA+C,6CAA6C,cAAc,MAAM,iDAAiD,wBAAwB,aAAa,YAAY,MAAM,sGAAsG,WAAW,8BAA8B,0DAA0D,sBAAsB,SAAS,yCAAyC,qCAAqC,iEAAiE,mDAAmD,uEAAuE,YAAY,SAAS,kDAAkD,iEAAiE,SAAS,+BAA+B,uGAAuG,+CAA+C,mCAAmC,yDAAyD,YAAY,SAAS,uCAAuC,sIAAsI,SAAS,wCAAwC,+BAA+B,6BAA6B,6BAA6B,iEAAiE,kCAAkC,sBAAsB,SAAS,8CAA8C,gDAAgD,+CAA+C,oCAAoC,sCAAsC,sCAAsC,0CAA0C,uBAAuB,SAAS,iDAAiD,iCAAiC,mEAAmE,YAAY,MAAM,4DAA4D,WAAW,SAAS,0CAA0C,2CAA2C,sBAAsB,SAAS,yCAAyC,QAAQ,EAAE,mFAAmF,0BAA0B,OAAO,wCAAwC,mCAAmC,uCAAuC,SAAS,uCAAuC,wCAAwC,SAAS,uCAAuC,wCAAwC,SAAS,wCAAwC,8CAA8C,SAAS,oCAAoC,mDAAmD,SAAS,QAAQ,EAAE,qSAAqS,2BAA2B,6CAA6C,uBAAuB,EAAE,yCAAyC,uBAAuB,6BAA6B,2BAA2B,yBAAyB,6CAA6C,qCAAqC,iCAAiC,wCAAwC,yCAAyC,qCAAqC,qDAAqD,SAAS,uCAAuC,qEAAqE,SAAS,8CAA8C,gDAAgD,wCAAwC,mBAAmB,6DAA6D,oBAAoB,6DAA6D,sBAAsB,+DAA+D,iBAAiB,0DAA0D,2BAA2B,uCAAuC,wBAAwB,uCAAuC,QAAQ,EAAE,oCAAoC,uCAAuC,iEAAiE,0CAA0C,mCAAmC,0BAA0B,gCAAgC,iCAAiC,kCAAkC,2BAA2B,2BAA2B,OAAO,kDAAkD,4CAA4C,uFAAuF,6FAA6F,oCAAoC,2CAA2C,8DAA8D,8EAA8E,SAAS,0CAA0C,2CAA2C,sBAAsB,SAAS,6DAA6D,iGAAiG,SAAS,mDAAmD,sDAAsD,SAAS,gDAAgD,sIAAsI,SAAS,oDAAoD,wEAAwE,SAAS,oCAAoC,iIAAiI,uDAAuD,+CAA+C,2CAA2C,wBAAwB,YAAY,SAAS,2CAA2C,2KAA2K,4DAA4D,+CAA+C,8CAA8C,wBAAwB,YAAY,SAAS,iCAAiC,0CAA0C,4CAA4C,kDAAkD,YAAY,SAAS,iCAAiC,0CAA0C,4CAA4C,kDAAkD,YAAY,SAAS,iCAAiC,0CAA0C,4CAA4C,kDAAkD,YAAY,SAAS,yCAAyC,gJAAgJ,6DAA6D,+DAA+D,+DAA+D,wBAAwB,YAAY,SAAS,oCAAoC,0CAA0C,kDAAkD,wDAAwD,YAAY,SAAS,oCAAoC,0CAA0C,kDAAkD,wDAAwD,YAAY,SAAS,oCAAoC,0CAA0C,kDAAkD,wDAAwD,YAAY,SAAS,8CAA8C,yDAAyD,SAAS,oCAAoC,iCAAiC,kDAAkD,4EAA4E,YAAY,SAAS,gCAAgC,2HAA2H,mCAAmC,6CAA6C,gCAAgC,+BAA+B,cAAc,MAAM,oCAAoC,aAAa,kCAAkC,0DAA0D,cAAc,MAAM,0DAA0D,aAAa,wDAAwD,YAAY,SAAS,qCAAqC,uCAAuC,6BAA6B,sBAAsB,QAAQ,yCAAyC,aAAa,wBAAwB,WAAW,kCAAkC,yGAAyG,sBAAsB,WAAW,kDAAkD,2CAA2C,6CAA6C,aAAa,iCAAiC,kCAAkC,gBAAgB,EAAE,yCAAyC,YAAY,MAAM,uGAAuG,WAAW,sBAAsB,SAAS,sCAAsC,uCAAuC,6BAA6B,sBAAsB,QAAQ,4CAA4C,aAAa,wBAAwB,WAAW,sDAAsD,gCAAgC,iCAAiC,oCAAoC,kBAAkB,EAAE,6CAA6C,WAAW,sBAAsB,SAAS,yCAAyC,sDAAsD,SAAS,6CAA6C,0DAA0D,SAAS,wDAAwD,oDAAoD,qDAAqD,OAAO,QAAQ,2CAA2C,gEAAgE,yCAAyC,4BAA4B,aAAa,WAAW,2BAA2B,SAAS,wDAAwD,uDAAuD,yCAAyC,kEAAkE,SAAS,0CAA0C,uCAAuC,kCAAkC,gEAAgE,4DAA4D,2CAA2C,kEAAkE,0BAA0B,YAAY,SAAS,0CAA0C,4CAA4C,8DAA8D,uDAAuD,kDAAkD,sFAAsF,YAAY,SAAS,uCAAuC,uCAAuC,0CAA0C,2DAA2D,yDAAyD,2CAA2C,uEAAuE,0BAA0B,YAAY,SAAS,2CAA2C,4CAA4C,+DAA+D,yDAAyD,kDAAkD,uEAAuE,YAAY,SAAS,kCAAkC,0CAA0C,2BAA2B,uCAAuC,gDAAgD,OAAO,QAAQ,+CAA+C,WAAW,SAAS,iDAAiD,+CAA+C,2BAA2B,uCAAuC,gDAAgD,OAAO,QAAQ,sDAAsD,WAAW,SAAS,mDAAmD,mCAAmC,kCAAkC,+BAA+B,iDAAiD,WAAW,SAAS,oCAAoC,4EAA4E,6CAA6C,SAAS,gDAAgD,2DAA2D,uDAAuD,yCAAyC,mDAAmD,cAAc,MAAM,wFAAwF,aAAa,gDAAgD,yBAAyB,WAAW,mEAAmE,gDAAgD,OAAO,QAAQ,qDAAqD,WAAW,SAAS,oCAAoC,2IAA2I,0BAA0B,2LAA2L,oDAAoD,0BAA0B,0BAA0B,yBAAyB,uBAAuB,uBAAuB,YAAY,+BAA+B,wGAAwG,WAAW,sEAAsE,kCAAkC,gCAAgC,0DAA0D,iEAAiE,uEAAuE,6DAA6D,oDAAoD,oCAAoC,gDAAgD,8DAA8D,0DAA0D,+DAA+D,aAAa,gCAAgC,WAAW,8CAA8C,0EAA0E,sDAAsD,gFAAgF,6CAA6C,8CAA8C,oDAAoD,OAAO,QAAQ,0CAA0C,kDAAkD,iBAAiB,gBAAgB,MAAM,iDAAiD,eAAe,aAAa,WAAW,8CAA8C,mDAAmD,6BAA6B,yDAAyD,OAAO,QAAQ,8EAA8E,eAAe,sCAAsC,cAAc,MAAM,2EAA2E,aAAa,WAAW,uDAAuD,iCAAiC,6BAA6B,0BAA0B,QAAQ,+EAA+E,aAAa,WAAW,+BAA+B,iEAAiE,6DAA6D,2DAA2D,uDAAuD,uDAAuD,wEAAwE,mEAAmE,gEAAgE,0DAA0D,0DAA0D,WAAW,iCAAiC,wBAAwB,8JAA8J,4BAA4B,oCAAoC,sCAAsC,iCAAiC,gCAAgC,aAAa,wBAAwB,WAAW,SAAS,wCAAwC,gEAAgE,SAAS,+CAA+C,0DAA0D,kCAAkC,oCAAoC,gDAAgD,kDAAkD,wCAAwC,4CAA4C,oDAAoD,0DAA0D,oEAAoE,gDAAgD,sCAAsC,8CAA8C,kDAAkD,oDAAoD,8CAA8C,0EAA0E,qCAAqC,6BAA6B,4BAA4B,QAAQ,+CAA+C,sCAAsC,aAAa,WAAW,sBAAsB,SAAS,QAAQ,EAAE,4LAA4L,8BAA8B,6BAA6B,gDAAgD,4CAA4C,OAAO,8EAA8E,iGAAiG,kEAAkE,oEAAoE,8DAA8D,sBAAsB,SAAS,yCAAyC,4CAA4C,+DAA+D,yDAAyD,kDAAkD,yEAAyE,YAAY,SAAS,kDAAkD,mEAAmE,iEAAiE,SAAS,6BAA6B,qDAAqD,SAAS,QAAQ,EAAE,2LAA2L,4BAA4B,yCAAyC,sBAAsB,uBAAuB,yBAAyB,yBAAyB,qBAAqB,2BAA2B,wDAAwD,oDAAoD,sCAAsC,OAAO,wFAAwF,yHAAyH,gEAAgE,kCAAkC,kCAAkC,8BAA8B,oCAAoC,gCAAgC,8BAA8B,kCAAkC,mEAAmE,gBAAgB,sBAAsB,SAAS,iFAAiF,qCAAqC,yBAAyB,iLAAiL,WAAW,mCAAmC,wCAAwC,0CAA0C,8BAA8B,8BAA8B,gCAAgC,kCAAkC,wCAAwC,SAAS,uCAAuC,qCAAqC,sCAAsC,WAAW,wCAAwC,SAAS,8CAA8C,kEAAkE,gEAAgE,gDAAgD,gDAAgD,6BAA6B,4BAA4B,0BAA0B,6BAA6B,0DAA0D,8EAA8E,8EAA8E,oEAAoE,qEAAqE,2DAA2D,8DAA8D,wDAAwD,+DAA+D,WAAW,kGAAkG,SAAS,oCAAoC,kEAAkE,uCAAuC,qCAAqC,uCAAuC,mCAAmC,yCAAyC,qCAAqC,mCAAmC,wEAAwE,cAAc,sBAAsB,SAAS,QAAQ,EAAE,4KAA4K,mBAAmB,iBAAiB,iBAAiB,8EAA8E,iEAAiE,sEAAsE,8DAA8D,6EAA6E,OAAO,uCAAuC,4BAA4B,qDAAqD,SAAS,oCAAoC,4BAA4B,0BAA0B,0BAA0B,4CAA4C,wCAAwC,oDAAoD,6DAA6D,QAAQ,QAAQ,wEAAwE,WAAW,4DAA4D,QAAQ,QAAQ,sEAAsE,WAAW,sBAAsB,SAAS,QAAQ,EAAE,0UAA0U,8DAA8D,6CAA6C,yBAAyB,EAAE,yCAAyC,uBAAuB,6BAA6B,2BAA2B,uBAAuB,sBAAsB,gCAAgC,+BAA+B,6BAA6B,8BAA8B,4BAA4B,gCAAgC,gCAAgC,iCAAiC,+DAA+D,sCAAsC,iCAAiC,qCAAqC,oCAAoC,2CAA2C,oCAAoC,OAAO,uFAAuF,iGAAiG,qEAAqE,sDAAsD,QAAQ,QAAQ,4CAA4C,wCAAwC,WAAW,mDAAmD,QAAQ,QAAQ,uCAAuC,+DAA+D,6DAA6D,QAAQ,QAAQ,+EAA+E,aAAa,WAAW,4CAA4C,sCAAsC,WAAW,+CAA+C,yCAAyC,WAAW,yCAAyC,sCAAsC,sBAAsB,SAAS,+BAA+B,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,iCAAiC,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,iCAAiC,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,mCAAmC,gEAAgE,gDAAgD,0CAA0C,mCAAmC,wBAAwB,YAAY,SAAS,+BAA+B,4DAA4D,4CAA4C,oCAAoC,mCAAmC,wBAAwB,YAAY,SAAS,gCAAgC,mCAAmC,4CAA4C,iCAAiC,+BAA+B,2CAA2C,YAAY,SAAS,sDAAsD,2BAA2B,mFAAmF,6CAA6C,oDAAoD,4FAA4F,yFAAyF,gFAAgF,mFAAmF,iEAAiE,+BAA+B,yBAAyB,0BAA0B,kCAAkC,sBAAsB,kBAAkB,yGAAyG,0CAA0C,kGAAkG,aAAa,yCAAyC,8FAA8F,aAAa,sCAAsC,oEAAoE,aAAa,uCAAuC,uEAAuE,aAAa,WAAW,sDAAsD,8IAA8I,6IAA6I,wFAAwF,qCAAqC,sCAAsC,oHAAoH,aAAa,uCAAuC,uHAAuH,aAAa,WAAW,uCAAuC,oCAAoC,6BAA6B,mBAAmB,QAAQ,sCAAsC,sCAAsC,oCAAoC,uDAAuD,QAAQ,UAAU,8CAA8C,mGAAmG,kBAAkB,MAAM,kEAAkE,iBAAiB,eAAe,aAAa,YAAY,MAAM,0CAA0C,+BAA+B,oBAAoB,UAAU,4EAA4E,eAAe,cAAc,MAAM,+BAA+B,0BAA0B,UAAU,2CAA2C,eAAe,aAAa,WAAW,oCAAoC,gDAAgD,4DAA4D,WAAW,mDAAmD,kEAAkE,WAAW,sBAAsB,SAAS,8BAA8B,oCAAoC,6DAA6D,yDAAyD,wBAAwB,SAAS,iCAAiC,uCAAuC,kDAAkD,gDAAgD,kDAAkD,qCAAqC,uJAAuJ,qCAAqC,sBAAsB,SAAS,0CAA0C,qDAAqD,mDAAmD,QAAQ,QAAQ,uCAAuC,6CAA6C,2CAA2C,2CAA2C,oCAAoC,kCAAkC,yBAAyB,2BAA2B,mCAAmC,WAAW,SAAS,0DAA0D,gEAAgE,2CAA2C,uDAAuD,kDAAkD,QAAQ,QAAQ,0CAA0C,WAAW,+BAA+B,0JAA0J,qDAAqD,iDAAiD,QAAQ,QAAQ,qCAAqC,2CAA2C,yCAAyC,yCAAyC,sCAAsC,oCAAoC,2BAA2B,2CAA2C,yCAAyC,yCAAyC,aAAa,YAAY,MAAM,sCAAsC,iDAAiD,QAAQ,QAAQ,qCAAqC,oDAAoD,kDAAkD,kDAAkD,aAAa,WAAW,kDAAkD,QAAQ,QAAQ,sCAAsC,WAAW,+CAA+C,QAAQ,QAAQ,mCAAmC,mDAAmD,+CAA+C,4DAA4D,0DAA0D,0DAA0D,cAAc,MAAM,8DAA8D,4DAA4D,4DAA4D,aAAa,WAAW,wCAAwC,0CAA0C,WAAW,SAAS,gDAAgD,0BAA0B,oCAAoC,+CAA+C,QAAQ,QAAQ,mCAAmC,mDAAmD,+CAA+C,qDAAqD,mDAAmD,mDAAmD,cAAc,MAAM,uDAAuD,qDAAqD,qDAAqD,aAAa,WAAW,wCAAwC,0CAA0C,WAAW,SAAS,2CAA2C,iCAAiC,+LAA+L,QAAQ,QAAQ,mCAAmC,gDAAgD,8DAA8D,cAAc,MAAM,4DAA4D,aAAa,oFAAoF,yDAAyD,QAAQ,QAAQ,0DAA0D,oFAAoF,gBAAgB,MAAM,kFAAkF,eAAe,aAAa,WAAW,sHAAsH,kCAAkC,sDAAsD,QAAQ,QAAQ,kFAAkF,0CAA0C,oDAAoD,sDAAsD,sEAAsE,wEAAwE,4CAA4C,mDAAmD,QAAQ,QAAQ,2CAA2C,gCAAgC,uDAAuD,kDAAkD,qDAAqD,eAAe,aAAa,sDAAsD,yGAAyG,4EAA4E,wCAAwC,4EAA4E,iDAAiD,QAAQ,QAAQ,qCAAqC,yDAAyD,4DAA4D,6CAA6C,8DAA8D,4DAA4D,4DAA4D,aAAa,WAAW,oFAAoF,QAAQ,QAAQ,mCAAmC,oDAAoD,4DAA4D,WAAW,SAAS,4CAA4C,oBAAoB,qCAAqC,iDAAiD,QAAQ,QAAQ,0BAA0B,iEAAiE,aAAa,wCAAwC,WAAW,SAAS,0CAA0C,4CAA4C,0CAA0C,WAAW,0DAA0D,SAAS,6CAA6C,+CAA+C,+CAA+C,WAAW,6DAA6D,SAAS,oEAAoE,wDAAwD,6GAA6G,iBAAiB,WAAW,+WAA+W,2EAA2E,uCAAuC,mEAAmE,WAAW,uEAAuE,QAAQ,QAAQ,wCAAwC,4CAA4C,0EAA0E,yCAAyC,WAAW,mEAAmE,QAAQ,QAAQ,iDAAiD,WAAW,6DAA6D,QAAQ,QAAQ,gKAAgK,wGAAwG,8CAA8C,+CAA+C,uEAAuE,aAAa,4DAA4D,QAAQ,QAAQ,sDAAsD,iDAAiD,gEAAgE,eAAe,oDAAoD,aAAa,8CAA8C,2DAA2D,QAAQ,QAAQ,4CAA4C,wDAAwD,aAAa,8EAA8E,oCAAoC,WAAW,yDAAyD,QAAQ,QAAQ,4CAA4C,qCAAqC,uBAAuB,aAAa,6CAA6C,QAAQ,QAAQ,6CAA6C,aAAa,gCAAgC,WAAW,SAAS,uCAAuC,4CAA4C,qGAAqG,iBAAiB,WAAW,uDAAuD,mDAAmD,SAAS,6LAA6L,gCAAgC,kIAAkI,qBAAqB,iCAAiC,iHAAiH,wBAAwB,2BAA2B,kDAAkD,QAAQ,QAAQ,mCAAmC,0HAA0H,qDAAqD,qCAAqC,8CAA8C,6CAA6C,cAAc,MAAM,iGAAiG,yDAAyD,aAAa,WAAW,kKAAkK,+CAA+C,QAAQ,QAAQ,mCAAmC,uCAAuC,qCAAqC,qCAAqC,iDAAiD,uJAAuJ,OAAO,QAAQ,gEAAgE,8CAA8C,oBAAoB,eAAe,aAAa,WAAW,oDAAoD,QAAQ,QAAQ,+CAA+C,wCAAwC,yDAAyD,QAAQ,QAAQ,uDAAuD,aAAa,WAAW,iGAAiG,+BAA+B,oBAAoB,SAAS,6CAA6C,6BAA6B,8CAA8C,OAAO,QAAQ,oCAAoC,8EAA8E,WAAW,sBAAsB,SAAS,gDAAgD,iCAAiC,kCAAkC,iDAAiD,YAAY,QAAQ,+BAA+B,WAAW,qEAAqE,qDAAqD,WAAW,0CAA0C,kEAAkE,2CAA2C,+BAA+B,6DAA6D,2DAA2D,2BAA2B,YAAY,QAAQ,oCAAoC,sDAAsD,oDAAoD,WAAW,2DAA2D,yDAAyD,SAAS,8BAA8B,sBAAsB,qBAAqB,yGAAyG,UAAU,4EAA4E,8BAA8B,sDAAsD,gDAAgD,6CAA6C,2CAA2C,qFAAqF,aAAa,wBAAwB,WAAW,4BAA4B,2BAA2B,0BAA0B,QAAQ,4CAA4C,wDAAwD,WAAW,yBAAyB,yBAAyB,6BAA6B,wBAAwB,4BAA4B,qBAAqB,yBAAyB,2BAA2B,uBAAuB,QAAQ,uCAAuC,mCAAmC,iCAAiC,wFAAwF,uDAAuD,kEAAkE,4FAA4F,gEAAgE,6BAA6B,iDAAiD,iEAAiE,sDAAsD,4DAA4D,0DAA0D,gEAAgE,yDAAyD,+DAA+D,mCAAmC,+CAA+C,2CAA2C,oCAAoC,+DAA+D,mLAAmL,aAAa,kCAAkC,0DAA0D,aAAa,wCAAwC,qDAAqD,+LAA+L,aAAa,iCAAiC,wDAAwD,aAAa,uCAAuC,mDAAmD,yLAAyL,aAAa,WAAW,uDAAuD,yFAAyF,WAAW,6CAA6C,uFAAuF,sDAAsD,yCAAyC,aAAa,qDAAqD,uDAAuD,uCAAuC,WAAW,2CAA2C,oFAAoF,qDAAqD,wCAAwC,aAAa,+CAA+C,wCAAwC,sCAAsC,WAAW,qCAAqC,yDAAyD,kDAAkD,qCAAqC,aAAa,6CAA6C,iCAAiC,mCAAmC,WAAW,yBAAyB,wCAAwC,oCAAoC,2DAA2D,uDAAuD,kEAAkE,sBAAsB,SAAS,6BAA6B,qFAAqF,4CAA4C,2BAA2B,0CAA0C,4CAA4C,YAAY,sEAAsE,oDAAoD,yBAAyB,YAAY,sDAAsD,wDAAwD,SAAS,oCAAoC,kCAAkC,+CAA+C,yBAAyB,wBAAwB,kCAAkC,+BAA+B,+BAA+B,8BAA8B,8BAA8B,gCAAgC,gCAAgC,mCAAmC,mDAAmD,8DAA8D,6CAA6C,QAAQ,QAAQ,wDAAwD,WAAW,wDAAwD,2CAA2C,QAAQ,QAAQ,oDAAoD,WAAW,qDAAqD,0CAA0C,QAAQ,QAAQ,kDAAkD,WAAW,qFAAqF,QAAQ,QAAQ,0DAA0D,0DAA0D,2CAA2C,aAAa,oDAAoD,QAAQ,QAAQ,yDAAyD,4CAA4C,QAAQ,QAAQ,kCAAkC,2CAA2C,eAAe,sDAAsD,aAAa,WAAW,2EAA2E,iDAAiD,QAAQ,QAAQ,iCAAiC,oDAAoD,oFAAoF,wCAAwC,mEAAmE,QAAQ,QAAQ,qFAAqF,eAAe,aAAa,kFAAkF,uCAAuC,kEAAkE,QAAQ,QAAQ,mFAAmF,eAAe,aAAa,kDAAkD,WAAW,2EAA2E,iDAAiD,QAAQ,QAAQ,iCAAiC,+FAA+F,6CAA6C,wEAAwE,QAAQ,QAAQ,2EAA2E,wCAAwC,+DAA+D,6DAA6D,6DAA6D,mEAAmE,eAAe,aAAa,2FAA2F,2CAA2C,sEAAsE,QAAQ,QAAQ,2FAA2F,eAAe,aAAa,kDAAkD,WAAW,wEAAwE,gDAAgD,QAAQ,QAAQ,8DAA8D,WAAW,wEAAwE,gDAAgD,QAAQ,QAAQ,8DAA8D,WAAW,8EAA8E,kDAAkD,QAAQ,QAAQ,0DAA0D,WAAW,wEAAwE,uCAAuC,mDAAmD,WAAW,iFAAiF,0CAA0C,yDAAyD,WAAW,uFAAuF,4DAA4D,kDAAkD,0DAA0D,wDAAwD,sEAAsE,wDAAwD,sBAAsB,SAAS,+BAA+B,gCAAgC,kBAAkB,EAAE,SAAS,QAAQ,EAAE,yHAAyH,uCAAuC,yFAAyF,SAAS,yCAAyC,qBAAqB,2BAA2B,+BAA+B,qEAAqE,4CAA4C,6BAA6B,2BAA2B,wBAAwB,+CAA+C,yBAAyB,OAAO,wEAAwE,iCAAiC,gDAAgD,SAAS,QAAQ,EAAE,iDAAiD,sEAAsE,yCAAyC,2FAA2F,WAAW,8EAA8E,2BAA2B,SAAS,yCAAyC,+BAA+B,sBAAsB,SAAS,oCAAoC,oEAAoE,wCAAwC,kCAAkC,4CAA4C,wCAAwC,sBAAsB,SAAS,yDAAyD,kCAAkC,qCAAqC,8CAA8C,OAAO,QAAQ,qEAAqE,WAAW,sBAAsB,SAAS,wCAAwC,kCAAkC,sBAAsB,SAAS,+CAA+C,6CAA6C,8CAA8C,OAAO,QAAQ,oCAAoC,wCAAwC,+FAA+F,gCAAgC,aAAa,yCAAyC,uCAAuC,uCAAuC,WAAW,sBAAsB,SAAS,iDAAiD,6CAA6C,+CAA+C,OAAO,QAAQ,qCAAqC,yCAAyC,uCAAuC,uCAAuC,WAAW,sBAAsB,SAAS,kDAAkD,6CAA6C,+CAA+C,OAAO,QAAQ,sCAAsC,yCAAyC,kGAAkG,mCAAmC,aAAa,0CAA0C,wCAAwC,WAAW,sBAAsB,SAAS,kDAAkD,6CAA6C,+CAA+C,OAAO,QAAQ,sCAAsC,yCAAyC,kGAAkG,mCAAmC,aAAa,0CAA0C,wCAAwC,wCAAwC,WAAW,sBAAsB,SAAS,kDAAkD,6CAA6C,+CAA+C,OAAO,QAAQ,sCAAsC,yCAAyC,kGAAkG,mCAAmC,aAAa,0CAA0C,wCAAwC,wCAAwC,wCAAwC,WAAW,sBAAsB,SAAS,0CAA0C,iDAAiD,0CAA0C,sBAAsB,SAAS,mCAAmC,qDAAqD,SAAS,sCAAsC,kDAAkD,sBAAsB,SAAS,mCAAmC,yDAAyD,SAAS,sCAAsC,sDAAsD,sBAAsB,SAAS,mCAAmC,yDAAyD,SAAS,sCAAsC,sDAAsD,sBAAsB,SAAS,mCAAmC,yDAAyD,SAAS,sCAAsC,sDAAsD,sBAAsB,SAAS,0CAA0C,iCAAiC,sCAAsC,oCAAoC,sBAAsB,SAAS,8CAA8C,iCAAiC,sCAAsC,oCAAoC,oCAAoC,sBAAsB,SAAS,kDAAkD,iCAAiC,sCAAsC,oCAAoC,oCAAoC,oCAAoC,sBAAsB,SAAS,0CAA0C,2CAA2C,sBAAsB,SAAS,6BAA6B,gFAAgF,SAAS,QAAQ,EAAE,2EAA2E,mFAAmF,OAAO,iFAAiF,oEAAoE,sEAAsE,oFAAoF,OAAO,kFAAkF,sEAAsE,6EAA6E,2FAA2F,OAAO,yFAAyF,oFAAoF,sEAAsE,oFAAoF,OAAO,kFAAkF,sEAAsE,uEAAuE,qFAAqF,OAAO,mFAAmF,wEAAwE,sEAAsE,oFAAoF,OAAO,kFAAkF,sEAAsE,uEAAuE,qFAAqF,OAAO,mFAAmF,wEAAwE,wEAAwE,sFAAsF,OAAO,oFAAoF,0EAA0E,wEAAwE,sFAAsF,OAAO,oFAAoF,0EAA0E,2FAA2F,0BAA0B,yBAAyB,wBAAwB,uBAAuB,oBAAoB,qBAAqB,yBAAyB,+BAA+B,8BAA8B,4BAA4B,mCAAmC,gCAAgC,iCAAiC,+DAA+D,qCAAqC,oCAAoC,iCAAiC,oCAAoC,OAAO,gDAAgD,8CAA8C,oBAAoB,wBAAwB,sCAAsC,qCAAqC,2BAA2B,kBAAkB,QAAQ,kCAAkC,iFAAiF,iDAAiD,0CAA0C,sDAAsD,mCAAmC,eAAe,uBAAuB,mFAAmF,aAAa,WAAW,sCAAsC,kDAAkD,+BAA+B,WAAW,+BAA+B,SAAS,8CAA8C,qCAAqC,yCAAyC,mDAAmD,oFAAoF,mFAAmF,sEAAsE,qDAAqD,mCAAmC,yCAAyC,sCAAsC,6BAA6B,wBAAwB,QAAQ,6CAA6C,aAAa,8DAA8D,WAAW,mDAAmD,qDAAqD,iCAAiC,yCAAyC,oCAAoC,6BAA6B,wBAAwB,QAAQ,2CAA2C,aAAa,0DAA0D,WAAW,mEAAmE,+CAA+C,sEAAsE,oEAAoE,uCAAuC,kBAAkB,QAAQ,kCAAkC,6FAA6F,mDAAmD,+CAA+C,8FAA8F,cAAc,MAAM,uCAAuC,0DAA0D,aAAa,iDAAiD,8CAA8C,0FAA0F,cAAc,MAAM,qCAAqC,sDAAsD,aAAa,6CAA6C,sDAAsD,8CAA8C,gFAAgF,gBAAgB,MAAM,8FAA8F,6EAA6E,eAAe,aAAa,8CAA8C,sDAAsD,8CAA8C,iFAAiF,gBAAgB,MAAM,+FAA+F,8EAA8E,eAAe,aAAa,kDAAkD,wBAAwB,QAAQ,2DAA2D,oHAAoH,aAAa,6BAA6B,wBAAwB,QAAQ,qEAAqE,0FAA0F,aAAa,uDAAuD,2GAA2G,aAAa,mCAAmC,2GAA2G,aAAa,WAAW,yCAAyC,gEAAgE,4DAA4D,0DAA0D,oDAAoD,0DAA0D,sBAAsB,SAAS,QAAQ,EAAE,4FAA4F,oDAAoD,6BAA6B,2CAA2C,OAAO,QAAQ,mDAAmD,SAAS,mBAAmB,OAAO,6IAA6I,yEAAyE,6CAA6C,+BAA+B,EAAE,yCAAyC,uBAAuB,mCAAmC,0BAA0B,2BAA2B,kCAAkC,yBAAyB,gCAAgC,iCAAiC,2BAA2B,4BAA4B,OAAO,6FAA6F,kGAAkG,4BAA4B,SAAS,uCAAuC,yCAAyC,uHAAuH,YAAY,MAAM,+BAA+B,WAAW,SAAS,qDAAqD,8HAA8H,qGAAqG,6FAA6F,mBAAmB,WAAW,mCAAmC,sGAAsG,qCAAqC,mBAAmB,WAAW,8CAA8C,sBAAsB,SAAS,0CAA0C,yCAAyC,SAAS,6CAA6C,yCAAyC,sBAAsB,SAAS,6DAA6D,6BAA6B,oIAAoI,EAAE,SAAS,mCAAmC,2BAA2B,SAAS,kDAAkD,uCAAuC,qCAAqC,SAAS,2CAA2C,kDAAkD,yCAAyC,sDAAsD,sCAAsC,WAAW,8CAA8C,uCAAuC,uEAAuE,0DAA0D,oCAAoC,WAAW,4CAA4C,sCAAsC,WAAW,+CAA+C,yCAAyC,WAAW,sBAAsB,SAAS,+BAA+B,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,iCAAiC,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,iCAAiC,iFAAiF,4CAA4C,sCAAsC,mCAAmC,wBAAwB,YAAY,SAAS,mCAAmC,gEAAgE,gDAAgD,0CAA0C,mCAAmC,wBAAwB,YAAY,SAAS,+BAA+B,4DAA4D,4CAA4C,oCAAoC,mCAAmC,wBAAwB,YAAY,SAAS,gCAAgC,mCAAmC,4CAA4C,iCAAiC,+BAA+B,2CAA2C,YAAY,SAAS,gCAAgC,oCAAoC,6DAA6D,yDAAyD,wBAAwB,SAAS,6CAA6C,6FAA6F,yCAAyC,mDAAmD,0FAA0F,mFAAmF,8FAA8F,kFAAkF,yGAAyG,iGAAiG,qGAAqG,aAAa,qDAAqD,oEAAoE,aAAa,kDAAkD,8DAA8D,aAAa,YAAY,2BAA2B,oDAAoD,4CAA4C,aAAa,WAAW,sBAAsB,SAAS,6CAA6C,4BAA4B,8CAA8C,OAAO,QAAQ,oCAAoC,0DAA0D,WAAW,qFAAqF,sBAAsB,SAAS,gDAAgD,yCAAyC,gCAAgC,mDAAmD,yDAAyD,iCAAiC,gDAAgD,aAAa,yCAAyC,mDAAmD,aAAa,oEAAoE,gEAAgE,8DAA8D,wDAAwD,8DAA8D,gDAAgD,6CAA6C,4CAA4C,yCAAyC,4CAA4C,8BAA8B,WAAW,wBAAwB,uDAAuD,iDAAiD,4CAA4C,+DAA+D,yCAAyC,aAAa,gDAAgD,WAAW,sDAAsD,+CAA+C,4CAA4C,8DAA8D,yCAAyC,aAAa,+CAA+C,WAAW,qDAAqD,8CAA8C,4CAA4C,2DAA2D,yCAAyC,aAAa,8CAA8C,WAAW,yCAAyC,2CAA2C,4CAA4C,0DAA0D,yCAAyC,aAAa,2CAA2C,WAAW,mDAAmD,qDAAqD,4CAA4C,4DAA4D,yCAAyC,aAAa,qDAAqD,WAAW,4CAA4C,sDAAsD,wCAAwC,8CAA8C,WAAW,sBAAsB,SAAS,8CAA8C,oFAAoF,sEAAsE,SAAS,oDAAoD,2EAA2E,oHAAoH,8CAA8C,0EAA0E,iHAAiH,WAAW,6CAA6C,wEAAwE,4GAA4G,WAAW,0CAA0C,kEAAkE,qGAAqG,WAAW,2CAA2C,oEAAoE,wGAAwG,WAAW,8CAA8C,6FAA6F,qEAAqE,kGAAkG,WAAW,2DAA2D,wEAAwE,2BAA2B,2DAA2D,sDAAsD,OAAO,QAAQ,kDAAkD,sFAAsF,uEAAuE,aAAa,iDAAiD,WAAW,uEAAuE,+FAA+F,kGAAkG,WAAW,kDAAkD,+FAA+F,mGAAmG,WAAW,+DAA+D,kEAAkE,WAAW,gDAAgD,4DAA4D,WAAW,sBAAsB,SAAS,0CAA0C,4CAA4C,0CAA0C,WAAW,kDAAkD,yCAAyC,gEAAgE,YAAY,MAAM,yCAAyC,WAAW,wHAAwH,yKAAyK,WAAW,SAAS,6CAA6C,+BAA+B,mCAAmC,mDAAmD,iDAAiD,iDAAiD,aAAa,oDAAoD,6BAA6B,sDAAsD,qDAAqD,oCAAoC,mMAAmM,oDAAoD,QAAQ,QAAQ,8CAA8C,4CAA4C,4CAA4C,wFAAwF,eAAe,oEAAoE,0DAA0D,wKAAwK,eAAe,aAAa,YAAY,SAAS,4CAA4C,6CAA6C,4CAA4C,iCAAiC,yCAAyC,iCAAiC,sCAAsC,sDAAsD,oDAAoD,4GAA4G,cAAc,MAAM,iGAAiG,kDAAkD,QAAQ,QAAQ,+BAA+B,eAAe,aAAa,kDAAkD,2BAA2B,yEAAyE,qDAAqD,yDAAyD,wCAAwC,0CAA0C,mDAAmD,eAAe,mDAAmD,QAAQ,QAAQ,wCAAwC,wCAAwC,sCAAsC,yDAAyD,QAAQ,UAAU,4CAA4C,0CAA0C,0CAA0C,gDAAgD,8CAA8C,8CAA8C,0CAA0C,wCAAwC,+BAA+B,wCAAwC,0CAA0C,0CAA0C,wCAAwC,0CAA0C,0CAA0C,wCAAwC,0CAA0C,0CAA0C,iBAAiB,eAAe,cAAc,MAAM,uHAAuH,QAAQ,UAAU,6CAA6C,+CAA+C,+CAA+C,wCAAwC,sCAAsC,6BAA6B,oCAAoC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,sCAAsC,wCAAwC,sCAAsC,sCAAsC,eAAe,aAAa,oCAAoC,iDAAiD,WAAW,SAAS,+CAA+C,8DAA8D,yHAAyH,iBAAiB,WAAW,iDAAiD,2CAA2C,yCAAyC,qEAAqE,+CAA+C,iDAAiD,wDAAwD,iDAAiD,oDAAoD,yDAAyD,4BAA4B,cAAc,0DAA0D,aAAa,WAAW,sBAAsB,SAAS,wCAAwC,qCAAqC,8CAA8C,iDAAiD,iDAAiD,QAAQ,QAAQ,2CAA2C,yCAAyC,yCAAyC,iCAAiC,gEAAgE,aAAa,YAAY,SAAS,sCAAsC,sCAAsC,oGAAoG,sBAAsB,WAAW,+CAA+C,yCAAyC,yCAAyC,0CAA0C,+CAA+C,wCAAwC,4CAA4C,4EAA4E,sCAAsC,iDAAiD,OAAO,QAAQ,8CAA8C,+BAA+B,cAAc,QAAQ,wDAAwD,eAAe,aAAa,oFAAoF,WAAW,2BAA2B,SAAS,8BAA8B,sBAAsB,qBAAqB,qHAAqH,UAAU,kFAAkF,8BAA8B,sDAAsD,gDAAgD,6CAA6C,2CAA2C,qFAAqF,aAAa,wBAAwB,WAAW,wBAAwB,iBAAiB,iCAAiC,iCAAiC,kEAAkE,+BAA+B,mFAAmF,WAAW,2CAA2C,yCAAyC,8CAA8C,sEAAsE,2CAA2C,6KAA6K,WAAW,mCAAmC,oCAAoC,sEAAsE,WAAW,mDAAmD,0CAA0C,wCAAwC,yGAAyG,WAAW,sBAAsB,SAAS,6BAA6B,qFAAqF,4CAA4C,2BAA2B,0CAA0C,4CAA4C,YAAY,sEAAsE,oDAAoD,yBAAyB,YAAY,sDAAsD,8DAA8D,SAAS,oCAAoC,yBAAyB,8CAA8C,6BAA6B,kCAAkC,yBAAyB,gCAAgC,mCAAmC,mDAAmD,qDAAqD,iCAAiC,2CAA2C,WAAW,oEAAoE,sCAAsC,+CAA+C,uDAAuD,WAAW,oFAAoF,2CAA2C,2BAA2B,wDAAwD,uGAAuG,OAAO,QAAQ,wDAAwD,aAAa,iDAAiD,WAAW,wDAAwD,0CAA0C,OAAO,QAAQ,oCAAoC,yEAAyE,WAAW,wEAAwE,uCAAuC,mDAAmD,WAAW,iFAAiF,0CAA0C,yDAAyD,WAAW,+EAA+E,sDAAsD,sBAAsB,SAAS,+BAA+B,gCAAgC,kBAAkB,EAAE,SAAS,QAAQ,EAAE,mOAAmO,8BAA8B,kCAAkC,2BAA2B,yLAAyL,+HAA+H,2BAA2B,OAAO,kEAAkE,oDAAoD,kIAAkI,oCAAoC,wCAAwC,2BAA2B,yLAAyL,yBAAyB,2BAA2B,2BAA2B,yBAAyB,4EAA4E,yDAAyD,uDAAuD,2CAA2C,wBAAwB,uBAAuB,mBAAmB,4DAA4D,yBAAyB,qJAAqJ,0GAA0G,qGAAqG,yGAAyG,wGAAwG,4GAA4G,+DAA+D,iFAAiF,8EAA8E,sEAAsE,uGAAuG,2CAA2C,2CAA2C,oCAAoC,oCAAoC,kCAAkC,iCAAiC,+BAA+B,gCAAgC,2BAA2B,qBAAqB,qCAAqC,uEAAuE,aAAa,SAAS,oDAAoD,0BAA0B,aAAa,SAAS,oDAAoD,4FAA4F,mCAAmC,oCAAoC,8GAA8G,qFAAqF,4BAA4B,8CAA8C,6GAA6G,yDAAyD,2CAA2C,0DAA0D,aAAa,WAAW,8NAA8N,YAAY,SAAS,0BAA0B,YAAY,SAAS,0DAA0D,gEAAgE,wEAAwE,gEAAgE,4DAA4D,oCAAoC,+DAA+D,aAAa,WAAW,mJAAmJ,oFAAoF,wFAAwF,SAAS,OAAO,8EAA8E,gEAAgE,iNAAiN,8BAA8B,oCAAoC,2BAA2B,+HAA+H,2GAA2G,2BAA2B,OAAO,oEAAoE,wDAAwD,gHAAgH,oCAAoC,0CAA0C,2BAA2B,+HAA+H,2BAA2B,2BAA2B,mCAAmC,mCAAmC,qDAAqD,oDAAoD,+BAA+B,6BAA6B,0CAA0C,0CAA0C,mBAAmB,2CAA2C,wBAAwB,uBAAuB,mBAAmB,mEAAmE,aAAa,SAAS,oDAAoD,wBAAwB,aAAa,SAAS,oDAAoD,uCAAuC,oCAAoC,mCAAmC,yCAAyC,WAAW,SAAS,wCAAwC,YAAY,SAAS,wBAAwB,YAAY,SAAS,qCAAqC,2CAA2C,mDAAmD,2CAA2C,wDAAwD,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,gFAAgF,oEAAoE,iIAAiI,quBAAquB,uDAAuD,8BAA8B,wCAAwC,4CAA4C,mCAAmC,6BAA6B,mCAAmC,0BAA0B,gCAAgC,gCAAgC,6BAA6B,2BAA2B,uCAAuC,4BAA4B,kCAAkC,+BAA+B,kCAAkC,sCAAsC,uCAAuC,8BAA8B,gCAAgC,4BAA4B,qCAAqC,OAAO,wEAAwE,gEAAgE,6DAA6D,8DAA8D,qDAAqD,wCAAwC,8BAA8B,wCAAwC,wDAAwD,kCAAkC,kDAAkD,8CAA8C,wCAAwC,oCAAoC,oCAAoC,8CAA8C,oDAAoD,0CAA0C,0DAA0D,sDAAsD,wDAAwD,wCAAwC,8CAA8C,oBAAoB,QAAQ,uFAAuF,mBAAmB,uBAAuB,qBAAqB,kBAAkB,YAAY,oBAAoB,aAAa,2QAA2Q,oDAAoD,8BAA8B,qCAAqC,0BAA0B,yBAAyB,0CAA0C,+EAA+E,IAAI,EAAE,0CAA0C,gDAAgD,IAAI,EAAE,2BAA2B,+BAA+B,kCAAkC,0BAA0B,kDAAkD,uDAAuD,yEAAyE,yEAAyE,4DAA4D,sDAAsD,gPAAgP,yNAAyN,mFAAmF,6CAA6C,yCAAyC,sDAAsD,uHAAuH,WAAW,uCAAuC,SAAS,OAAO,qEAAqE,0DAA0D,uDAAuD,2DAA2D,qDAAqD,oDAAoD,8CAA8C,+DAA+D,sCAAsC,0CAA0C,0DAA0D,oCAAoC,sCAAsC,wCAAwC,gDAAgD,8CAA8C,4CAA4C,oBAAoB,QAAQ,2DAA2D,gEAAgE,sCAAsC,4CAA4C,gDAAgD,oBAAoB,QAAQ,kGAAkG,wEAAwE,+EAA+E,OAAO,qCAAqC,6CAA6C,qCAAqC,yCAAyC,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,iCAAiC,yCAAyC,6CAA6C,sBAAsB,SAAS,6CAA6C,uDAAuD,sFAAsF,SAAS,iCAAiC,kEAAkE,sBAAsB,SAAS,8BAA8B,iCAAiC,uCAAuC,iDAAiD,wBAAwB,YAAY,SAAS,oEAAoE,uDAAuD,gDAAgD,6DAA6D,wCAAwC,8CAA8C,WAAW,sGAAsG,SAAS,8CAA8C,8DAA8D,SAAS,yCAAyC,iCAAiC,sDAAsD,8FAA8F,6EAA6E,4DAA4D,aAAa,6FAA6F,iDAAiD,YAAY,SAAS,6CAA6C,wCAAwC,mCAAmC,iCAAiC,qGAAqG,yZAAyZ,kDAAkD,oDAAoD,sDAAsD,mDAAmD,8CAA8C,wCAAwC,kCAAkC,8CAA8C,sCAAsC,4BAA4B,uFAAuF,+BAA+B,qCAAqC,8BAA8B,uCAAuC,uCAAuC,2IAA2I,+BAA+B,+BAA+B,kGAAkG,oBAAoB,MAAM,kEAAkE,0DAA0D,iEAAiE,mBAAmB,kBAAkB,MAAM,gEAAgE,wDAAwD,+DAA+D,iBAAiB,gBAAgB,MAAM,uCAAuC,gGAAgG,qGAAqG,+DAA+D,kBAAkB,0BAA0B,sDAAsD,0EAA0E,mDAAmD,kBAAkB,MAAM,8FAA8F,mGAAmG,+DAA+D,iBAAiB,eAAe,cAAc,MAAM,uGAAuG,oDAAoD,2DAA2D,aAAa,uCAAuC,gGAAgG,aAAa,2CAA2C,0FAA0F,aAAa,2BAA2B,YAAY,SAAS,yCAAyC,iCAAiC,qEAAqE,wDAAwD,6CAA6C,4CAA4C,sDAAsD,4CAA4C,gDAAgD,oGAAoG,sGAAsG,kIAAkI,wSAAwS,8IAA8I,YAAY,SAAS,kDAAkD,wEAAwE,SAAS,8CAA8C,+DAA+D,oCAAoC,2GAA2G,uBAAuB,aAAa,gHAAgH,WAAW,uFAAuF,4FAA4F,SAAS,6DAA6D,gDAAgD,6BAA6B,wBAAwB,WAAW,8CAA8C,SAAS,8CAA8C,sHAAsH,oCAAoC,wBAAwB,WAAW,+DAA+D,gDAAgD,wBAAwB,WAAW,8FAA8F,SAAS,yDAAyD,qDAAqD,+HAA+H,mCAAmC,+BAA+B,sDAAsD,oDAAoD,YAAY,MAAM,sDAAsD,oDAAoD,WAAW,+BAA+B,uDAAuD,qDAAqD,YAAY,MAAM,uDAAuD,qDAAqD,WAAW,kEAAkE,wMAAwM,4DAA4D,+BAA+B,uDAAuD,qDAAqD,YAAY,MAAM,uDAAuD,qDAAqD,WAAW,kEAAkE,4DAA4D,4DAA4D,iGAAiG,oEAAoE,SAAS,uCAAuC,gCAAgC,gDAAgD,wDAAwD,YAAY,UAAU,4CAA4C,2FAA2F,kCAAkC,kCAAkC,mCAAmC,yFAAyF,0IAA0I,mCAAmC,8CAA8C,6WAA6W,mBAAmB,4BAA4B,iDAAiD,qBAAqB,cAAc,qBAAqB,yBAAyB,wBAAwB,cAAc,MAAM,0BAA0B,aAAa,8CAA8C,sFAAsF,mEAAmE,0BAA0B,aAAa,0EAA0E,mEAAmE,0BAA0B,aAAa,iFAAiF,0BAA0B,aAAa,2GAA2G,+DAA+D,0BAA0B,aAAa,6FAA6F,YAAY,SAAS,+CAA+C,8CAA8C,qDAAqD,sBAAsB,SAAS,mCAAmC,4FAA4F,SAAS,QAAQ,EAAE,6FAA6F,qEAAqE,6DAA6D,OAAO,uCAAuC,sCAAsC,mCAAmC,6BAA6B,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,kCAAkC,wCAAwC,kCAAkC,sBAAsB,SAAS,iDAAiD,uDAAuD,+EAA+E,SAAS,6CAA6C,uDAAuD,yDAAyD,SAAS,kCAAkC,0DAA0D,SAAS,gCAAgC,mDAAmD,SAAS,6CAA6C,uDAAuD,4EAA4E,SAAS,oDAAoD,qCAAqC,qCAAqC,8EAA8E,mDAAmD,sDAAsD,qDAAqD,uDAAuD,gDAAgD,gCAAgC,yCAAyC,aAAa,qBAAqB,YAAY,SAAS,iFAAiF,0EAA0E,uDAAuD,4EAA4E,SAAS,4CAA4C,4CAA4C,wCAAwC,sBAAsB,SAAS,oCAAoC,gFAAgF,SAAS,QAAQ,EAAE,uIAAuI,yDAAyD,uDAAuD,uDAAuD,OAAO,gCAAgC,6BAA6B,iCAAiC,6DAA6D,yDAAyD,sCAAsC,gCAAgC,6BAA6B,mDAAmD,qCAAqC,8EAA8E,aAAa,yCAAyC,YAAY,SAAS,0LAA0L,iCAAiC,+BAA+B,+BAA+B,gFAAgF,kCAAkC,gCAAgC,oCAAoC,qCAAqC,mCAAmC,mCAAmC,mCAAmC,mCAAmC,0DAA0D,yDAAyD,2EAA2E,4LAA4L,aAAa,qCAAqC,+DAA+D,+DAA+D,0GAA0G,YAAY,SAAS,uCAAuC,iCAAiC,2DAA2D,2EAA2E,8FAA8F,YAAY,SAAS,UAAU,EAAE,0CAA0C,mCAAmC,2BAA2B,yBAAyB,yBAAyB,sBAAsB,SAAS,mEAAmE,sCAAsC,oCAAoC,oCAAoC,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,sCAAsC,oCAAoC,kCAAkC,kCAAkC,sBAAsB,SAAS,4BAA4B,iCAAiC,+BAA+B,kCAAkC,4CAA4C,0CAA0C,iDAAiD,YAAY,SAAS,kDAAkD,uDAAuD,yFAAyF,SAAS,8CAA8C,2EAA2E,SAAS,6CAA6C,qDAAqD,wEAAwE,SAAS,iEAAiE,8FAA8F,SAAS,4CAA4C,yEAAyE,SAAS,2CAA2C,kCAAkC,iEAAiE,2CAA2C,yCAAyC,wEAAwE,yDAAyD,qCAAqC,iIAAiI,sDAAsD,iIAAiI,6FAA6F,cAAc,MAAM,oLAAoL,gDAAgD,gDAAgD,+BAA+B,qBAAqB,QAAQ,wFAAwF,gFAAgF,+CAA+C,yCAAyC,8CAA8C,iBAAiB,eAAe,aAAa,0BAA0B,YAAY,SAAS,0CAA0C,2GAA2G,SAAS,QAAQ,EAAE,oPAAoP,8BAA8B,2BAA2B,iFAAiF,mFAAmF,kCAAkC,EAAE,0CAA0C,kCAAkC,OAAO,4EAA4E,wFAAwF,gCAAgC,SAAS,oCAAoC,uDAAuD,0CAA0C,6DAA6D,8EAA8E,WAAW,6DAA6D,0DAA0D,iCAAiC,WAAW,sBAAsB,SAAS,0CAA0C,uCAAuC,wBAAwB,4CAA4C,2DAA2D,oDAAoD,oCAAoC,gEAAgE,mDAAmD,gDAAgD,8CAA8C,yDAAyD,QAAQ,QAAQ,iEAAiE,uDAAuD,uDAAuD,iBAAiB,eAAe,aAAa,YAAY,MAAM,qDAAqD,0EAA0E,8CAA8C,4CAA4C,qDAAqD,QAAQ,QAAQ,6DAA6D,qDAAqD,qDAAqD,eAAe,aAAa,WAAW,SAAS,iCAAiC,4CAA4C,4BAA4B,kCAAkC,iCAAiC,+BAA+B,+BAA+B,oCAAoC,kCAAkC,kCAAkC,kCAAkC,gCAAgC,gCAAgC,wCAAwC,gDAAgD,mDAAmD,uEAAuE,wEAAwE,8CAA8C,4CAA4C,4CAA4C,sCAAsC,+BAA+B,WAAW,6FAA6F,0BAA0B,+CAA+C,2EAA2E,cAAc,MAAM,mGAAmG,aAAa,kDAAkD,iDAAiD,oEAAoE,qFAAqF,qFAAqF,oBAAoB,uHAAuH,WAAW,qGAAqG,kDAAkD,gDAAgD,gDAAgD,2HAA2H,iCAAiC,yBAAyB,iDAAiD,+CAA+C,+CAA+C,iGAAiG,eAAe,sFAAsF,uCAAuC,aAAa,gCAAgC,WAAW,4DAA4D,yCAAyC,uCAAuC,6CAA6C,iDAAiD,2IAA2I,mDAAmD,6CAA6C,6EAA6E,kEAAkE,kEAAkE,oGAAoG,gFAAgF,aAAa,6BAA6B,8CAA8C,0BAA0B,uCAAuC,wDAAwD,4CAA4C,qBAAqB,qCAAqC,wFAAwF,OAAO,UAAU,sCAAsC,wCAAwC,wCAAwC,gHAAgH,uCAAuC,kEAAkE,gGAAgG,mBAAmB,iBAAiB,gBAAgB,oCAAoC,+FAA+F,OAAO,UAAU,wBAAwB,0BAA0B,0BAA0B,gHAAgH,uCAAuC,4CAA4C,kGAAkG,mBAAmB,iBAAiB,eAAe,cAAc,iCAAiC,gCAAgC,4DAA4D,+CAA+C,uCAAuC,oBAAoB,8DAA8D,gEAAgE,kDAAkD,QAAQ,QAAQ,sCAAsC,6FAA6F,2DAA2D,yCAAyC,uCAAuC,uCAAuC,2DAA2D,2DAA2D,iEAAiE,oCAAoC,kCAAkC,kCAAkC,6DAA6D,QAAQ,QAAQ,yDAAyD,oDAAoD,6DAA6D,gGAAgG,8FAA8F,8FAA8F,mBAAmB,gCAAgC,8BAA8B,8BAA8B,2BAA2B,yBAAyB,yBAAyB,iBAAiB,yHAAyH,qCAAqC,0CAA0C,yCAAyC,yCAAyC,yCAAyC,yCAAyC,wGAAwG,mBAAmB,2CAA2C,2CAA2C,gDAAgD,iBAAiB,eAAe,aAAa,YAAY,SAAS,iCAAiC,mFAAmF,SAAS,QAAQ,EAAE,6IAA6I,+CAA+C,yBAAyB,mCAAmC,kBAAkB,kEAAkE,4CAA4C,sCAAsC,+CAA+C,YAAY,8CAA8C,sCAAsC,4BAA4B,WAAW,mDAAmD,0GAA0G,WAAW,yDAAyD,0CAA0C,mHAAmH,qTAAqT,eAAe,2DAA2D,qDAAqD,6EAA6E,oEAAoE,gBAAgB,oDAAoD,aAAa,+DAA+D,oFAAoF,YAAY,gDAAgD,8CAA8C,2EAA2E,wHAAwH,kDAAkD,eAAe,sDAAsD,aAAa,gDAAgD,iKAAiK,WAAW,SAAS,2CAA2C,+FAA+F,SAAS,gBAAgB,sCAAsC,8BAA8B,WAAW,mDAAmD,oCAAoC,uDAAuD,6CAA6C,WAAW,qCAAqC,8BAA8B,WAAW,4CAA4C,+BAA+B,6CAA6C,WAAW,iCAAiC,OAAO,oGAAoG,gDAAgD,+CAA+C,UAAU,+DAA+D,6CAA6C,UAAU,6CAA6C,+CAA+C,UAAU,yBAAyB,2BAA2B,UAAU,MAAM,6BAA6B,SAAS,OAAO,iDAAiD,gDAAgD,+CAA+C,UAAU,oBAAoB,2BAA2B,UAAU,MAAM,6BAA6B,SAAS,OAAO,kCAAkC,6BAA6B,+BAA+B,wBAAwB,2BAA2B,yBAAyB,+BAA+B,4BAA4B,+BAA+B,SAAS,+DAA+D,2DAA2D,2CAA2C,0BAA0B,0PAA0P,yDAAyD,YAAY,MAAM,sCAAsC,qCAAqC,yCAAyC,yCAAyC,gDAAgD,sDAAsD,2BAA2B,mCAAmC,WAAW,sFAAsF,8BAA8B,SAAS,yBAAyB,oEAAoE,mFAAmF,SAAS,gBAAgB,4HAA4H,OAAO,mCAAmC,uBAAuB,uCAAuC,gDAAgD,iCAAiC,qCAAqC,8DAA8D,yCAAyC,+BAA+B,WAAW,sBAAsB,SAAS,4BAA4B,qBAAqB,SAAS,gBAAgB,iDAAiD,OAAO,mGAAmG,uDAAuD,OAAO,wCAAwC,gCAAgC,kDAAkD,gEAAgE,8DAA8D,+CAA+C,yDAAyD,2CAA2C,0DAA0D,6BAA6B,YAAY,QAAQ,yCAAyC,aAAa,uDAAuD,WAAW,wFAAwF,oFAAoF,sEAAsE,YAAY,QAAQ,4CAA4C,yCAAyC,gFAAgF,8EAA8E,aAAa,WAAW,0DAA0D,YAAY,QAAQ,4CAA4C,+BAA+B,iDAAiD,WAAW,8CAA8C,2DAA2D,OAAO,QAAQ,4CAA4C,8BAA8B,yCAAyC,uCAAuC,4BAA4B,sGAAsG,oGAAoG,6CAA6C,uBAAuB,eAAe,aAAa,qCAAqC,WAAW,yFAAyF,SAAS,gBAAgB,kCAAkC,OAAO,mIAAmI,iBAAiB,mCAAmC,uBAAuB,SAAS,kCAAkC,oCAAoC,4BAA4B,gDAAgD,SAAS,yCAAyC,wEAAwE,8BAA8B,qCAAqC,qEAAqE,kEAAkE,SAAS,4DAA4D,qEAAqE,qCAAqC,qKAAqK,iBAAiB,WAAW,yHAAyH,8BAA8B,kEAAkE,kGAAkG,+FAA+F,SAAS,yCAAyC,+BAA+B,2BAA2B,6CAA6C,OAAO,4HAA4H,iBAAiB,mCAAmC,uBAAuB,SAAS,yCAAyC,8CAA8C,8BAA8B,qCAAqC,qEAAqE,kEAAkE,SAAS,4DAA4D,qEAAqE,qCAAqC,8JAA8J,iBAAiB,WAAW,sDAAsD,wDAAwD,wCAAwC,6FAA6F,YAAY,MAAM,iGAAiG,WAAW,8BAA8B,kEAAkE,kGAAkG,+FAA+F,SAAS,yCAAyC,2BAA2B,6CAA6C,OAAO,wHAAwH,4BAA4B,mCAAmC,6CAA6C,sCAAsC,uDAAuD,gDAAgD,sDAAsD,WAAW,yDAAyD,mEAAmE,WAAW,uEAAuE,2CAA2C,oGAAoG,4BAA4B,2CAA2C,oDAAoD,WAAW,+DAA+D,4BAA4B,2CAA2C,0DAA0D,WAAW,+CAA+C,SAAS,0CAA0C,yDAAyD,sDAAsD,oEAAoE,4CAA4C,sCAAsC,YAAY,iCAAiC,2DAA2D,sFAAsF,aAAa,sDAAsD,WAAW,qDAAqD,mCAAmC,gCAAgC,SAAS,qCAAqC,qCAAqC,qDAAqD,iCAAiC,gEAAgE,WAAW,kDAAkD,6EAA6E,WAAW,mFAAmF,+CAA+C,gDAAgD,+CAA+C,OAAO,QAAQ,+DAA+D,aAAa,WAAW,SAAS,oDAAoD,6DAA6D,4CAA4C,2BAA2B,6CAA6C,qDAAqD,yCAAyC,yCAAyC,4CAA4C,+CAA+C,OAAO,UAAU,qCAAqC,mCAAmC,mCAAmC,+CAA+C,aAAa,YAAY,MAAM,0DAA0D,2DAA2D,OAAO,UAAU,4BAA4B,0BAA0B,0BAA0B,+CAA+C,aAAa,WAAW,4CAA4C,wHAAwH,kEAAkE,yDAAyD,2BAA2B,SAAS,gBAAgB,0GAA0G,OAAO,0FAA0F,wBAAwB,gBAAgB,mCAAmC,qDAAqD,wCAAwC,aAAa,yBAAyB,mCAAmC,gEAAgE,sOAAsO,oBAAoB,yDAAyD,6XAA6X,oBAAoB,0DAA0D,oWAAoW,oBAAoB,+DAA+D,uIAAuI,oBAAoB,6DAA6D,oPAAoP,oBAAoB,aAAa,0CAA0C,4BAA4B,WAAW,UAAU,OAAO,8BAA8B,wCAAwC,qBAAqB,iVAAiV,oCAAoC,kCAAkC,mCAAmC,mDAAmD,kCAAkC,oCAAoC,4BAA4B,2BAA2B,+BAA+B,2BAA2B,qDAAqD,8CAA8C,OAAO,QAAQ,oCAAoC,oCAAoC,0CAA0C,wCAAwC,mGAAmG,yCAAyC,uCAAuC,qCAAqC,qCAAqC,cAAc,sCAAsC,gDAAgD,mFAAmF,0EAA0E,sEAAsE,8CAA8C,gEAAgE,iDAAiD,uCAAuC,0CAA0C,kDAAkD,oDAAoD,sDAAsD,eAAe,0EAA0E,qFAAqF,8DAA8D,mCAAmC,cAAc,+BAA+B,gDAAgD,2EAA2E,yDAAyD,uEAAuE,yCAAyC,4EAA4E,sEAAsE,8CAA8C,gEAAgE,yDAAyD,oFAAoF,0EAA0E,iDAAiD,uCAAuC,0CAA0C,kDAAkD,oDAAoD,sDAAsD,eAAe,4DAA4D,uEAAuE,gDAAgD,4BAA4B,cAAc,mCAAmC,gDAAgD,oMAAoM,2IAA2I,2EAA2E,yDAAyD,oHAAoH,8CAA8C,8CAA8C,gDAAgD,oEAAoE,oEAAoE,0DAA0D,yDAAyD,uGAAuG,0DAA0D,gCAAgC,cAAc,gCAAgC,gDAAgD,2EAA2E,yDAAyD,mFAAmF,+CAA+C,0EAA0E,iDAAiD,uCAAuC,0CAA0C,kDAAkD,oDAAoD,sDAAsD,6DAA6D,2DAA2D,eAAe,8DAA8D,yEAAyE,kDAAkD,6BAA6B,cAAc,qCAAqC,gDAAgD,4EAA4E,gEAAgE,2CAA2C,gFAAgF,uFAAuF,kDAAkD,4BAA4B,aAAa,WAAW,iCAAiC,+BAA+B,+BAA+B,uDAAuD,uCAAuC,+CAA+C,yCAAyC,uCAAuC,uMAAuM,SAAS,gBAAgB,iDAAiD,OAAO,iHAAiH,4BAA4B,mCAAmC,uCAAuC,yCAAyC,gEAAgE,8FAA8F,wCAAwC,wDAAwD,aAAa,gDAAgD,oDAAoD,WAAW,gCAAgC,SAAS,0BAA0B,0BAA0B,SAAS,gBAAgB,uDAAuD,OAAO,mGAAmG,0CAA0C,yBAAyB,kBAAkB,QAAQ,qDAAqD,SAAS,mCAAmC,OAAO,gDAAgD,6CAA6C,0CAA0C,iCAAiC,6EAA6E,2EAA2E,SAAS,qDAAqD,iLAAiL,SAAS,yJAAyJ,sBAAsB,OAAO,uFAAuF,kDAAkD,6BAA6B,yEAAyE,mEAAmE,mEAAmE,yEAAyE,2EAA2E,0EAA0E,4FAA4F,iFAAiF,SAAS,OAAO,mEAAmE,2DAA2D,wDAAwD,gEAAgE,EAAE,OAAO,mEAAmE,2DAA2D,wDAAwD,2DAA2D,EAAE,OAAO,oEAAoE,4BAA4B,gCAAgC,sEAAsE,gBAAgB,0EAA0E,gBAAgB,8EAA8E,gBAAgB,+EAA+E,gBAAgB,yFAAyF,SAAS,0DAA0D,qDAAqD,EAAE,OAAO,iFAAiF,sCAAsC,grBAAgrB,8DAA8D,OAAO,2CAA2C,wBAAwB,qCAAqC,sCAAsC,0CAA0C,yDAAyD,SAAS,oCAAoC,OAAO,uDAAuD,4BAA4B,wEAAwE,yBAAyB,OAAO,QAAQ,sDAAsD,6BAA6B,oFAAoF,qEAAqE,SAAS,0BAA0B,OAAO,0CAA0C,6BAA6B,OAAO,uDAAuD,+VAA+V,OAAO,wCAAwC,2DAA2D,4CAA4C,+CAA+C,wCAAwC,4EAA4E,WAAW,0CAA0C,SAAS,kDAAkD,OAAO,sCAAsC,mDAAmD,cAAc,gBAAgB,kBAAkB,IAAI,GAAG,wDAAwD,0BAA0B,2CAA2C,qBAAqB,QAAQ,uEAAuE,WAAW,wBAAwB,SAAS,kDAAkD,OAAO,yFAAyF,kCAAkC,uCAAuC,+CAA+C,iDAAiD,yDAAyD,0DAA0D,qDAAqD,UAAU,2DAA2D,0DAA0D,SAAS,kDAAkD,sDAAsD,4DAA4D,kCAAkC,8CAA8C,8HAA8H,kBAAkB,qIAAqI,kBAAkB,uJAAuJ,kBAAkB,gGAAgG,kBAAkB,WAAW,8CAA8C,+IAA+I,kBAAkB,WAAW,uCAAuC,iGAAiG,kBAAkB,uFAAuF,kBAAkB,uFAAuF,kBAAkB,WAAW,SAAS,0FAA0F,kDAAkD,2GAA2G,uDAAuD,mDAAmD,yCAAyC,6CAA6C,uGAAuG,0CAA0C,kCAAkC,WAAW,oIAAoI,4CAA4C,oCAAoC,WAAW,UAAU,MAAM,oFAAoF,wDAAwD,izEAAizE,0CAA0C,2CAA2C,qCAAqC,uCAAuC,yCAAyC,uCAAuC,mCAAmC,+BAA+B,qEAAqE,wGAAwG,2CAA2C,2CAA2C,2CAA2C,uFAAuF,6CAA6C,6CAA6C,6CAA6C,qEAAqE,6CAA6C,6CAA6C,6CAA6C,wHAAwH,yCAAyC,4FAA4F,mHAAmH,wDAAwD,s2EAAs2E,yCAAyC,43CAA43C,SAAS,qDAAqD,kEAAkE,yDAAyD,sEAAsE,4CAA4C,qDAAqD,uDAAuD,SAAS,qDAAqD,yDAAyD,iDAAiD,mDAAmD,6EAA6E,iFAAiF,mDAAmD,mDAAmD,8GAA8G,4EAA4E,UAAU,8CAA8C,oIAAoI,SAAS,kCAAkC,yDAAyD,4DAA4D,gEAAgE,4BAA4B,iCAAiC,6HAA6H,+HAA+H,4EAA4E,2BAA2B,wNAAwN,UAAU,+BAA+B,mFAAmF,UAAU,oDAAoD,kCAAkC,SAAS,gCAAgC,8BAA8B,0HAA0H,0EAA0E,8BAA8B,8EAA8E,YAAY,SAAS,6DAA6D,0CAA0C,0EAA0E,wCAAwC,+CAA+C,wEAAwE,WAAW,gCAAgC,UAAU,8EAA8E,0CAA0C,iDAAiD,sEAAsE,WAAW,kCAAkC,UAAU,4DAA4D,sCAAsC,iCAAiC,UAAU,6DAA6D,qBAAqB,4BAA4B,qFAAqF,sCAAsC,aAAa,SAAS,wBAAwB,4BAA4B,yFAAyF,wCAAwC,aAAa,SAAS,UAAU,EAAE,gDAAgD,uBAAuB,yBAAyB,6BAA6B,yCAAyC,6CAA6C,oBAAoB,OAAO,8HAA8H,0BAA0B,yBAAyB,ueAAue,0/BAA0/B,4CAA4C,yCAAyC,mCAAmC,mDAAmD,wBAAwB,YAAY,MAAM,wXAAwX,2EAA2E,qEAAqE,4CAA4C,kIAAkI,qBAAqB,aAAa,4BAA4B,WAAW,SAAS,wEAAwE,uBAAuB,wBAAwB,sCAAsC,YAAY,2BAA2B,oCAAoC,YAAY,qCAAqC,0JAA0J,0CAA0C,WAAW,yMAAyM,qCAAqC,WAAW,0BAA0B,SAAS,kHAAkH,oDAAoD,8MAA8M,+CAA+C,8CAA8C,2EAA2E,qDAAqD,qIAAqI,aAAa,WAAW,+DAA+D,4BAA4B,86FAA86F,4BAA4B,UAAU,iEAAiE,yBAAyB,sCAAsC,8CAA8C,YAAY,MAAM,kDAAkD,8CAA8C,WAAW,iDAAiD,kDAAkD,iCAAiC,mDAAmD,aAAa,WAAW,2BAA2B,2BAA2B,QAAQ,4DAA4D,WAAW,4DAA4D,6CAA6C,8BAA8B,UAAU,+EAA+E,sBAAsB,mGAAmG,QAAQ,QAAQ,4CAA4C,8CAA8C,oCAAoC,iCAAiC,oBAAoB,aAAa,WAAW,wCAAwC,mGAAmG,mCAAmC,WAAW,yBAAyB,UAAU,oDAAoD,6CAA6C,sFAAsF,0DAA0D,yBAAyB,+DAA+D,WAAW,UAAU,6GAA6G,OAAO,+JAA+J,0HAA0H,8BAA8B,6DAA6D,kEAAkE,+LAA+L,8FAA8F,2DAA2D,6DAA6D,oDAAoD,yGAAyG,wKAAwK,0BAA0B,WAAW,uBAAuB,SAAS,wCAAwC,yFAAyF,SAAS,0CAA0C,0HAA0H,8FAA8F,8DAA8D,gEAAgE,oDAAoD,wEAAwE,iLAAiL,0BAA0B,WAAW,uBAAuB,SAAS,oDAAoD,8LAA8L,SAAS,uEAAuE,+IAA+I,SAAS,6FAA6F,6GAA6G,+BAA+B,WAAW,4BAA4B,SAAS,sDAAsD,qCAAqC,qEAAqE,uCAAuC,yCAAyC,gDAAgD,WAAW,iCAAiC,SAAS,iDAAiD,0CAA0C,+EAA+E,iDAAiD,iCAAiC,SAAS,yDAAyD,4DAA4D,+EAA+E,wGAAwG,YAAY,MAAM,+FAA+F,kEAAkE,WAAW,6EAA6E,SAAS,yDAAyD,sEAAsE,uEAAuE,uCAAuC,iEAAiE,kEAAkE,WAAW,4CAA4C,gDAAgD,WAAW,uDAAuD,6BAA6B,OAAO,QAAQ,sFAAsF,sIAAsI,aAAa,YAAY,MAAM,+EAA+E,+HAA+H,WAAW,oDAAoD,0CAA0C,SAAS,8DAA8D,4DAA4D,yFAAyF,sCAAsC,wCAAwC,+GAA+G,cAAc,sCAAsC,gHAAgH,cAAc,MAAM,gEAAgE,mBAAmB,aAAa,WAAW,qDAAqD,8EAA8E,SAAS,kDAAkD,4DAA4D,6CAA6C,2FAA2F,oEAAoE,wEAAwE,kFAAkF,uCAAuC,eAAe,yDAAyD,mGAAmG,wEAAwE,4EAA4E,2FAA2F,iCAAiC,+BAA+B,OAAO,QAAQ,0DAA0D,qGAAqG,kBAAkB,MAAM,iGAAiG,iBAAiB,eAAe,+MAA+M,uFAAuF,+BAA+B,OAAO,QAAQ,uCAAuC,wCAAwC,gLAAgL,oBAAoB,MAAM,2HAA2H,mBAAmB,kBAAkB,MAAM,+DAA+D,wDAAwD,QAAQ,QAAQ,0CAA0C,0FAA0F,4FAA4F,oJAAoJ,wBAAwB,MAAM,0IAA0I,uBAAuB,sBAAsB,MAAM,0JAA0J,qBAAqB,mBAAmB,iBAAiB,eAAe,gFAAgF,2DAA2D,eAAe,4DAA4D,kEAAkE,cAAc,MAAM,yDAAyD,mGAAmG,aAAa,WAAW,SAAS,yDAAyD,qDAAqD,4FAA4F,SAAS,kFAAkF,wBAAwB,oCAAoC,iGAAiG,+FAA+F,yGAAyG,uGAAuG,YAAY,MAAM,oFAAoF,kFAAkF,mGAAmG,uKAAuK,aAAa,0GAA0G,wGAAwG,8FAA8F,yKAAyK,aAAa,WAAW,yEAAyE,4BAA4B,8GAA8G,qHAAqH,4FAA4F,sJAAsJ,+EAA+E,aAAa,WAAW,SAAS,oEAAoE,8DAA8D,iDAAiD,oEAAoE,mEAAmE,2CAA2C,qDAAqD,aAAa,mCAAmC,WAAW,qDAAqD,8EAA8E,oEAAoE,wFAAwF,yEAAyE,mFAAmF,uFAAuF,4CAA4C,WAAW,8JAA8J,6EAA6E,gDAAgD,yCAAyC,0GAA0G,+CAA+C,qGAAqG,oDAAoD,cAAc,uBAAuB,6HAA6H,aAAa,6FAA6F,uWAAuW,8HAA8H,iDAAiD,qDAAqD,eAAe,aAAa,yNAAyN,iDAAiD,4TAA4T,mHAAmH,kDAAkD,qDAAqD,eAAe,aAAa,wHAAwH,YAAY,mCAAmC,8OAA8O,oDAAoD,QAAQ,QAAQ,sCAAsC,6HAA6H,eAAe,8CAA8C,cAAc,MAAM,0HAA0H,aAAa,YAAY,yCAAyC,kDAAkD,QAAQ,QAAQ,oCAAoC,oFAAoF,sFAAsF,yHAAyH,kBAAkB,MAAM,mIAAmI,iBAAiB,gBAAgB,MAAM,+HAA+H,eAAe,aAAa,YAAY,MAAM,mSAAmS,oDAAoD,QAAQ,QAAQ,sCAAsC,wFAAwF,eAAe,8CAA8C,cAAc,MAAM,uFAAuF,aAAa,WAAW,gHAAgH,wDAAwD,8DAA8D,SAAS,uMAAuM,sEAAsE,gEAAgE,2HAA2H,4DAA4D,yIAAyI,qDAAqD,SAAS,kKAAkK,iEAAiE,2EAA2E,wHAAwH,+GAA+G,YAAY,oEAAoE,oHAAoH,uHAAuH,YAAY,MAAM,gKAAgK,WAAW,yDAAyD,SAAS,4IAA4I,gFAAgF,mGAAmG,8DAA8D,8FAA8F,qGAAqG,WAAW,qSAAqS,uEAAuE,uEAAuE,uDAAuD,WAAW,uDAAuD,6FAA6F,mEAAmE,oHAAoH,YAAY,qEAAqE,4HAA4H,YAAY,MAAM,6DAA6D,WAAW,SAAS,mHAAmH,sEAAsE,yEAAyE,4CAA4C,wGAAwG,yFAAyF,YAAY,MAAM,2BAA2B,6DAA6D,+BAA+B,OAAO,QAAQ,uGAAuG,wFAAwF,uGAAuG,eAAe,cAAc,MAAM,gGAAgG,iFAAiF,gGAAgG,aAAa,WAAW,uDAAuD,SAAS,sGAAsG,sEAAsE,uEAAuE,4EAA4E,iEAAiE,iCAAiC,yEAAyE,8DAA8D,uDAAuD,2DAA2D,6BAA6B,OAAO,QAAQ,uFAAuF,aAAa,YAAY,MAAM,gFAAgF,WAAW,wDAAwD,wFAAwF,iGAAiG,6BAA6B,OAAO,QAAQ,kKAAkK,aAAa,sIAAsI,0DAA0D,YAAY,MAAM,kFAAkF,2FAA2F,oIAAoI,gIAAgI,oDAAoD,WAAW,uFAAuF,mDAAmD,WAAW,SAAS,2DAA2D,6CAA6C,8DAA8D,6EAA6E,sGAAsG,sEAAsE,sDAAsD,uCAAuC,4CAA4C,WAAW,SAAS,wCAAwC,4CAA4C,0CAA0C,WAAW,SAAS,yCAAyC,2CAA2C,yDAAyD,iDAAiD,+DAA+D,qDAAqD,OAAO,kGAAkG,4BAA4B,gCAAgC,iCAAiC,qCAAqC,oCAAoC,qBAAqB,mCAAmC,WAAW,qBAAqB,SAAS,mCAAmC,2CAA2C,SAAS,0BAA0B,0BAA0B,SAAS,gBAAgB,oEAAoE,OAAO,8GAA8G,gCAAgC,6BAA6B,oCAAoC,oCAAoC,0DAA0D,kBAAkB,6CAA6C,iEAAiE,2EAA2E,2CAA2C,eAAe,aAAa,2CAA2C,4BAA4B,aAAa,oEAAoE,kDAAkD,wBAAwB,QAAQ,OAAO,eAAe,sCAAsC,kEAAkE,4CAA4C,8CAA8C,eAAe,aAAa,iCAAiC,6BAA6B,sCAAsC,mDAAmD,oCAAoC,YAAY,SAAS,gCAAgC,6BAA6B,sCAAsC,oCAAoC,qCAAqC,kBAAkB,6CAA6C,gCAAgC,wCAAwC,gBAAgB,MAAM,yCAAyC,eAAe,aAAa,8CAA8C,iEAAiE,0CAA0C,2CAA2C,eAAe,aAAa,8CAA8C,qDAAqD,kCAAkC,wCAAwC,mFAAmF,0BAA0B,qFAAqF,0BAA0B,iFAAiF,0BAA0B,wFAAwF,0BAA0B,mFAAmF,0BAA0B,2FAA2F,0BAA0B,uFAAuF,0BAA0B,yFAAyF,0BAA0B,4EAA4E,mBAAmB,kBAAkB,MAAM,4CAA4C,iBAAiB,6CAA6C,eAAe,aAAa,2CAA2C,4BAA4B,aAAa,2CAA2C,kDAAkD,uCAAuC,wCAAwC,eAAe,aAAa,iCAAiC,6BAA6B,sCAAsC,oCAAoC,qCAAqC,aAAa,YAAY,SAAS,kCAAkC,6BAA6B,wCAAwC,sCAAsC,qCAAqC,0CAA0C,sCAAsC,uCAAuC,uCAAuC,uCAAuC,kBAAkB,+CAA+C,kCAAkC,0CAA0C,gBAAgB,MAAM,2CAA2C,eAAe,aAAa,gDAAgD,qEAAqE,8CAA8C,+CAA+C,eAAe,aAAa,yEAAyE,2KAA2K,uEAAuE,iDAAiD,6CAA6C,mDAAmD,eAAe,aAAa,0EAA0E,6KAA6K,wEAAwE,iDAAiD,iDAAiD,iDAAiD,eAAe,aAAa,2CAA2C,4BAA4B,aAAa,6CAA6C,sDAAsD,2CAA2C,4CAA4C,eAAe,aAAa,iCAAiC,6BAA6B,wCAAwC,sCAAsC,qCAAqC,0CAA0C,sCAAsC,uCAAuC,uCAAuC,uCAAuC,aAAa,YAAY,SAAS,sDAAsD,0CAA0C,8CAA8C,2EAA2E,gEAAgE,oEAAoE,oEAAoE,8BAA8B,4CAA4C,kCAAkC,mCAAmC,sCAAsC,iCAAiC,iCAAiC,2CAA2C,sCAAsC,sCAAsC,2CAA2C,oCAAoC,iCAAiC,oCAAoC,8CAA8C,2CAA2C,iFAAiF,kGAAkG,4DAA4D,sCAAsC,oCAAoC,2CAA2C,0CAA0C,uDAAuD,0CAA0C,iGAAiG,0CAA0C,oEAAoE,oEAAoE,2BAA2B,WAAW,QAAQ,8FAA8F,WAAW,yBAAyB,SAAS,+BAA+B,wFAAwF,qHAAqH,0DAA0D,gCAAgC,kCAAkC,gCAAgC,4CAA4C,8BAA8B,kCAAkC,6BAA6B,2BAA2B,oCAAoC,6CAA6C,qDAAqD,OAAO,QAAQ,mCAAmC,WAAW,SAAS,+CAA+C,yCAAyC,uDAAuD,oDAAoD,6CAA6C,WAAW,uDAAuD,uEAAuE,+DAA+D,6CAA6C,WAAW,SAAS,2EAA2E,yCAAyC,uDAAuD,oDAAoD,6CAA6C,WAAW,sEAAsE,uEAAuE,8EAA8E,4DAA4D,WAAW,SAAS,4CAA4C,yDAAyD,SAAS,QAAQ,kEAAkE,+CAA+C,uCAAuC,aAAa,WAAW,SAAS,+BAA+B,8CAA8C,4BAA4B,oCAAoC,WAAW,SAAS,gCAAgC,+CAA+C,6BAA6B,qCAAqC,WAAW,SAAS,gDAAgD,oDAAoD,0CAA0C,6MAA6M,6EAA6E,+BAA+B,oBAAoB,QAAQ,8DAA8D,eAAe,aAAa,WAAW,0CAA0C,SAAS,wCAAwC,6CAA6C,qCAAqC,qCAAqC,wBAAwB,WAAW,uBAAuB,SAAS,mJAAmJ,0CAA0C,+BAA+B,YAAY,MAAM,gCAAgC,WAAW,8CAA8C,oGAAoG,mCAAmC,mFAAmF,yEAAyE,yEAAyE,oBAAoB,MAAM,oDAAoD,uDAAuD,mBAAmB,sBAAsB,sFAAsF,yEAAyE,2GAA2G,oBAAoB,MAAM,oDAAoD,kEAAkE,mBAAmB,sBAAsB,mFAAmF,yEAAyE,uFAAuF,oBAAoB,MAAM,oDAAoD,wDAAwD,mBAAmB,sBAAsB,qEAAqE,yEAAyE,yGAAyG,oBAAoB,MAAM,yEAAyE,+GAA+G,mBAAmB,eAAe,aAAa,wCAAwC,iCAAiC,iCAAiC,2CAA2C,sCAAsC,sCAAsC,YAAY,MAAM,qEAAqE,oDAAoD,oDAAoD,+GAA+G,8GAA8G,mDAAmD,2DAA2D,aAAa,qKAAqK,2JAA2J,yCAAyC,uCAAuC,iDAAiD,iDAAiD,aAAa,WAAW,qCAAqC,sDAAsD,SAAS,uDAAuD,4GAA4G,yDAAyD,mDAAmD,oCAAoC,iSAAiS,oDAAoD,kDAAkD,mDAAmD,mDAAmD,gHAAgH,SAAS,sDAAsD,iDAAiD,8BAA8B,oCAAoC,cAAc,MAAM,qCAAqC,aAAa,yCAAyC,WAAW,SAAS,0CAA0C,4CAA4C,mCAAmC,iDAAiD,gDAAgD,uCAAuC,gBAAgB,wCAAwC,wCAAwC,gBAAgB,MAAM,iDAAiD,eAAe,aAAa,YAAY,MAAM,oCAAoC,WAAW,qCAAqC,SAAS,wCAAwC,6CAA6C,4DAA4D,qCAAqC,WAAW,SAAS,mEAAmE,gCAAgC,6CAA6C,iGAAiG,gDAAgD,kDAAkD,8CAA8C,aAAa,YAAY,MAAM,8CAA8C,WAAW,SAAS,gDAAgD,8BAA8B,sCAAsC,YAAY,MAAM,uCAAuC,WAAW,SAAS,+DAA+D,mFAAmF,mDAAmD,0CAA0C,yCAAyC,WAAW,SAAS,yDAAyD,8CAA8C,4BAA4B,WAAW,wEAAwE,6CAA6C,6BAA6B,sCAAsC,oEAAoE,WAAW,2FAA2F,oFAAoF,0CAA0C,8CAA8C,WAAW,SAAS,yCAAyC,eAAe,2DAA2D,YAAY,iBAAiB,wDAAwD,WAAW,SAAS,+BAA+B,eAAe,iDAAiD,YAAY,iBAAiB,wDAAwD,WAAW,SAAS,+CAA+C,6DAA6D,qEAAqE,yCAAyC,WAAW,SAAS,uCAAuC,+DAA+D,0EAA0E,2CAA2C,WAAW,SAAS,oCAAoC,2BAA2B,8BAA8B,QAAQ,iDAAiD,+CAA+C,uCAAuC,aAAa,WAAW,4BAA4B,0CAA0C,oCAAoC,kCAAkC,gCAAgC,iCAAiC,kCAAkC,+BAA+B,8BAA8B,4BAA4B,8BAA8B,SAAS,gBAAgB,oBAAoB,mGAAmG,80BAA80B,OAAO,0HAA0H,0BAA0B,qCAAqC,kEAAkE,6EAA6E,qCAAqC,wFAAwF,YAAY,MAAM,8BAA8B,WAAW,+BAA+B,SAAS,+CAA+C,wCAAwC,iMAAiM,6BAA6B,aAAa,kCAAkC,WAAW,0CAA0C,qMAAqM,+BAA+B,aAAa,WAAW,wBAAwB,SAAS,4FAA4F,sDAAsD,2CAA2C,8GAA8G,iCAAiC,SAAS,gFAAgF,wEAAwE,mFAAmF,kEAAkE,2EAA2E,qEAAqE,+EAA+E,kEAAkE,mFAAmF,mDAAmD,2EAA2E,wEAAwE,gBAAgB,woBAAwoB,OAAO,sPAAsP,4BAA4B,wCAAwC,gDAAgD,oBAAoB,oDAAoD,gDAAgD,sBAAsB,wDAAwD,uBAAuB,4BAA4B,yEAAyE,sFAAsF,OAAO,uFAAuF,uHAAuH,gEAAgE,gCAAgC,gCAAgC,kCAAkC,8BAA8B,kCAAkC,sCAAsC,mEAAmE,gBAAgB,4CAA4C,4CAA4C,sBAAsB,SAAS,gWAAgW,sJAAsJ,mEAAmE,sCAAsC,SAAS,kIAAkI,wEAAwE,2DAA2D,SAAS,uCAAuC,kHAAkH,SAAS,oCAAoC,mIAAmI,SAAS,qCAAqC,oIAAoI,SAAS,4eAA4e,wBAAwB,iCAAiC,kCAAkC,iGAAiG,yFAAyF,yFAAyF,yFAAyF,yFAAyF,yFAAyF,iLAAiL,+CAA+C,qCAAqC,yBAAyB,iLAAiL,WAAW,mCAAmC,wCAAwC,0CAA0C,8BAA8B,8BAA8B,gCAAgC,kCAAkC,wCAAwC,SAAS,uCAAuC,qCAAqC,sCAAsC,WAAW,wCAAwC,SAAS,8CAA8C,oPAAoP,0DAA0D,oFAAoF,qDAAqD,oDAAoD,0CAA0C,6CAA6C,WAAW,qCAAqC,oEAAoE,yGAAyG,SAAS,oCAAoC,kEAAkE,qCAAqC,qCAAqC,uCAAuC,mCAAmC,uCAAuC,2CAA2C,wEAAwE,cAAc,iDAAiD,iDAAiD,sBAAsB,SAAS,QAAQ,EAAE,+FAA+F,uCAAuC,mCAAmC,OAAO,4FAA4F,oEAAoE,EAAE,mGAAmG,yBAAyB,0BAA0B,2BAA2B,8BAA8B,yEAAyE,+CAA+C,SAAS,+CAA+C,8CAA8C,yDAAyD,iCAAiC,8CAA8C,yDAAyD,iCAAiC,+DAA+D,kCAAkC,kCAAkC,qDAAqD,6CAA6C,yDAAyD,kEAAkE,sDAAsD,wDAAwD,yDAAyD,2CAA2C,8EAA8E,YAAY,2BAA2B,sGAAsG,WAAW,SAAS,8CAA8C,+FAA+F,SAAS,uCAAuC,sCAAsC,wBAAwB,UAAU,6CAA6C,oDAAoD,UAAU,kDAAkD,0DAA0D,UAAU,8CAA8C,+CAA+C,yCAAyC,qCAAqC,2CAA2C,gDAAgD,mEAAmE,yCAAyC,2DAA2D,YAAY,MAAM,+CAA+C,WAAW,4CAA4C,gEAAgE,WAAW,yCAAyC,6DAA6D,iDAAiD,mCAAmC,mCAAmC,iCAAiC,0DAA0D,sEAAsE,2EAA2E,0EAA0E,yCAAyC,kCAAkC,gEAAgE,sEAAsE,oEAAoE,WAAW,8HAA8H,qEAAqE,+EAA+E,8EAA8E,gJAAgJ,sDAAsD,gCAAgC,oCAAoC,+EAA+E,2DAA2D,aAAa,iFAAiF,4DAA4D,aAAa,WAAW,0BAA0B,UAAU,wCAAwC,oEAAoE,UAAU,oCAAoC,gDAAgD,6FAA6F,WAAW,UAAU,OAAO,gGAAgG,4BAA4B,gBAAgB,kCAAkC,qDAAqD,wCAAwC,aAAa,0BAA0B,6BAA6B,+MAA+M,oBAAoB,2PAA2P,oBAAoB,uPAAuP,oBAAoB,gMAAgM,oBAAoB,gIAAgI,oBAAoB,wEAAwE,aAAa,uCAAuC,2FAA2F,aAAa,2CAA2C,6BAA6B,WAAW,UAAU,OAAO,oEAAoE,qPAAqP,kCAAkC,+BAA+B,yBAAyB,+BAA+B,sEAAsE,yRAAyR,qDAAqD,2DAA2D,wCAAwC,yBAAyB,UAAU,yCAAyC,kCAAkC,8BAA8B,UAAU,uCAAuC,mCAAmC,2BAA2B,UAAU,sGAAsG,wHAAwH,6EAA6E,+EAA+E,cAAc,MAAM,iCAAiC,aAAa,YAAY,MAAM,wJAAwJ,sCAAsC,iGAAiG,6BAA6B,eAAe,QAAQ,+CAA+C,aAAa,2CAA2C,uEAAuE,oCAAoC,WAAW,YAAY,qCAAqC,gDAAgD,wCAAwC,oDAAoD,WAAW,4CAA4C,kCAAkC,SAAS,4EAA4E,sFAAsF,gCAAgC,qCAAqC,gEAAgE,0GAA0G,6DAA6D,sEAAsE,wDAAwD,eAAe,+CAA+C,eAAe,iBAAiB,uFAAuF,qDAAqD,kDAAkD,eAAe,aAAa,qCAAqC,qCAAqC,WAAW,oCAAoC,0BAA0B,SAAS,OAAO,sHAAsH,+BAA+B,wBAAwB,uDAAuD,iEAAiE,sEAAsE,uDAAuD,iFAAiF,+EAA+E,qDAAqD,+EAA+E,6EAA6E,gEAAgE,4EAA4E,4EAA4E,yEAAyE,+CAA+C,+CAA+C,gEAAgE,2CAA2C,4DAA4D,+CAA+C,sCAAsC,mEAAmE,sEAAsE,WAAW,mDAAmD,6CAA6C,+CAA+C,yDAAyD,oEAAoE,2DAA2D,gEAAgE,sDAAsD,8DAA8D,6EAA6E,iDAAiD,6CAA6C,wDAAwD,0EAA0E,wDAAwD,0EAA0E,wDAAwD,0EAA0E,0DAA0D,0EAA0E,yEAAyE,mJAAmJ,0EAA0E,uCAAuC,8FAA8F,8FAA8F,8FAA8F,8FAA8F,aAAa,WAAW,8JAA8J,2EAA2E,uCAAuC,oGAAoG,kGAAkG,oGAAoG,oGAAoG,aAAa,WAAW,wCAAwC,0EAA0E,iFAAiF,WAAW,yDAAyD,6DAA6D,uCAAuC,gEAAgE,8DAA8D,aAAa,WAAW,2CAA2C,gEAAgE,+EAA+E,WAAW,mBAAmB,SAAS,iBAAiB,mBAAmB,OAAO,wRAAwR,uDAAuD,sCAAsC,w3BAAw3B,6BAA6B,4BAA4B,qCAAqC,8BAA8B,2BAA2B,8DAA8D,0BAA0B,iDAAiD,iCAAiC,iCAAiC,mCAAmC,sDAAsD,iEAAiE,wCAAwC,kEAAkE,8DAA8D,+BAA+B,uEAAuE,oEAAoE,qCAAqC,uCAAuC,kDAAkD,+BAA+B,6jCAA6jC,sDAAsD,0BAA0B,gHAAgH,qBAAqB,0FAA0F,wCAAwC,iEAAiE,SAAS,qCAAqC,aAAa,mCAAmC,2QAA2Q,0KAA0K,oFAAoF,8IAA8I,+BAA+B,2DAA2D,+FAA+F,cAAc,MAAM,iEAAiE,aAAa,WAAW,sJAAsJ,wDAAwD,uBAAuB,+CAA+C,cAAc,WAAW,UAAU,iBAAiB,mEAAmE,SAAS,4CAA4C,wEAAwE,oCAAoC,4EAA4E,wCAAwC,kBAAkB,kCAAkC,kDAAkD,gDAAgD,8CAA8C,qDAAqD,mDAAmD,0DAA0D,qDAAqD,mDAAmD,mDAAmD,oDAAoD,8EAA8E,2DAA2D,wFAAwF,2FAA2F,6CAA6C,6GAA6G,gDAAgD,yEAAyE,8DAA8D,oDAAoD,4EAA4E,mCAAmC,6CAA6C,4FAA4F,mFAAmF,+FAA+F,8FAA8F,8FAA8F,sDAAsD,8BAA8B,0CAA0C,sCAAsC,sCAAsC,wCAAwC,4BAA4B,SAAS,wBAAwB,wDAAwD,qBAAqB,+GAA+G,mCAAmC,qDAAqD,qBAAqB,UAAU,iDAAiD,4CAA4C,UAAU,6CAA6C,iEAAiE,iDAAiD,UAAU,gDAAgD,iEAAiE,oDAAoD,UAAU,0CAA0C,6BAA6B,UAAU,iDAAiD,4CAA4C,8BAA8B,iDAAiD,UAAU,oCAAoC,kBAAkB,2DAA2D,UAAU,gEAAgE,sCAAsC,gDAAgD,sGAAsG,iBAAiB,WAAW,yBAAyB,yBAAyB,8CAA8C,8CAA8C,wCAAwC,+CAA+C,+CAA+C,WAAW,kDAAkD,UAAU,iDAAiD,kBAAkB,uFAAuF,UAAU,4EAA4E,yBAAyB,yBAAyB,mCAAmC,6CAA6C,6CAA6C,kDAAkD,UAAU,6DAA6D,kEAAkE,2FAA2F,UAAU,4DAA4D,iEAAiE,wFAAwF,UAAU,oDAAoD,yDAAyD,UAAU,6DAA6D,4CAA4C,UAAU,0CAA0C,kEAAkE,UAAU,0CAA0C,4CAA4C,UAAU,0CAA0C,kEAAkE,UAAU,yDAAyD,uBAAuB,2EAA2E,yEAAyE,+EAA+E,4BAA4B,UAAU,uCAAuC,2CAA2C,UAAU,uCAAuC,2CAA2C,UAAU,yCAAyC,2CAA2C,UAAU,6EAA6E,+CAA+C,4CAA4C,UAAU,8CAA8C,kFAAkF,uFAAuF,gCAAgC,uBAAuB,UAAU,0DAA0D,iCAAiC,8DAA8D,gCAAgC,SAAS,kDAAkD,kEAAkE,iCAAiC,0BAA0B,SAAS,6CAA6C,sCAAsC,uEAAuE,yCAAyC,SAAS,+EAA+E,sDAAsD,wCAAwC,SAAS,gEAAgE,+DAA+D,uCAAuC,4CAA4C,uDAAuD,WAAW,SAAS,gGAAgG,8CAA8C,qEAAqE,YAAY,EAAE,SAAS,6EAA6E,iCAAiC,iDAAiD,iGAAiG,yFAAyF,6EAA6E,sFAAsF,0DAA0D,sCAAsC,iEAAiE,qFAAqF,gEAAgE,2FAA2F,WAAW,oCAAoC,+DAA+D,6LAA6L,qDAAqD,OAAO,UAAU,+CAA+C,kFAAkF,gFAAgF,gFAAgF,oCAAoC,kCAAkC,kCAAkC,oCAAoC,kCAAkC,kCAAkC,oCAAoC,kCAAkC,kCAAkC,eAAe,aAAa,qFAAqF,8DAA8D,2FAA2F,WAAW,gDAAgD,2DAA2D,+EAA+E,0DAA0D,uFAAuF,WAAW,yEAAyE,8DAA8D,kFAAkF,6DAA6D,0FAA0F,WAAW,0CAA0C,2DAA2D,2BAA2B,UAAU,+FAA+F,sFAAsF,qDAAqD,oEAAoE,qGAAqG,oCAAoC,8DAA8D,sDAAsD,+BAA+B,WAAW,+CAA+C,uEAAuE,iCAAiC,WAAW,iDAAiD,oDAAoD,4BAA4B,8CAA8C,iEAAiE,0BAA0B,WAAW,wBAAwB,sCAAsC,iCAAiC,gDAAgD,6CAA6C,yCAAyC,WAAW,gCAAgC,iEAAiE,mCAAmC,2EAA2E,aAAa,WAAW,wCAAwC,iCAAiC,oCAAoC,YAAY,oCAAoC,uCAAuC,WAAW,kEAAkE,gEAAgE,0EAA0E,+EAA+E,6DAA6D,kGAAkG,iEAAiE,wCAAwC,4CAA4C,gDAAgD,wFAAwF,0CAA0C,cAAc,MAAM,0CAA0C,yFAAyF,sBAAsB,kGAAkG,sBAAsB,8FAA8F,sBAAsB,eAAe,aAAa,cAAc,2BAA2B,+CAA+C,0DAA0D,8FAA8F,0CAA0C,4CAA4C,cAAc,+BAA+B,gDAAgD,cAAc,MAAM,iDAAiD,aAAa,YAAY,6BAA6B,2CAA2C,WAAW,iEAAiE,mDAAmD,yEAAyE,aAAa,YAAY,MAAM,oDAAoD,WAAW,UAAU,mFAAmF,iEAAiE,wEAAwE,gLAAgL,mBAAmB,aAAa,WAAW,yDAAyD,iCAAiC,uDAAuD,0DAA0D,+EAA+E,iDAAiD,6DAA6D,0CAA0C,iEAAiE,sDAAsD,8DAA8D,oDAAoD,oEAAoE,iIAAiI,8CAA8C,wCAAwC,8DAA8D,uEAAuE,oDAAoD,yCAAyC,sDAAsD,oEAAoE,+FAA+F,qEAAqE,sFAAsF,qBAAqB,oBAAoB,MAAM,8DAA8D,mBAAmB,6DAA6D,kKAAkK,kBAAkB,MAAM,uEAAuE,4GAA4G,qEAAqE,gHAAgH,qBAAqB,oBAAoB,MAAM,8DAA8D,mBAAmB,6DAA6D,4HAA4H,iBAAiB,gBAAgB,0DAA0D,mEAAmE,4CAA4C,2CAA2C,8FAA8F,0BAA0B,8FAA8F,0BAA0B,8FAA8F,0BAA0B,+FAA+F,mBAAmB,iBAAiB,eAAe,aAAa,WAAW,0CAA0C,SAAS,qEAAqE,iCAAiC,gCAAgC,+CAA+C,mCAAmC,yCAAyC,wCAAwC,4CAA4C,eAAe,aAAa,YAAY,EAAE,4DAA4D,+CAA+C,oCAAoC,uDAAuD,iCAAiC,4BAA4B,QAAQ,0EAA0E,iBAAiB,gBAAgB,MAAM,mEAAmE,eAAe,aAAa,YAAY,EAAE,UAAU,yDAAyD,kCAAkC,0BAA0B,oCAAoC,sCAAsC,gDAAgD,iDAAiD,YAAY,MAAM,iDAAiD,WAAW,6BAA6B,SAAS,+BAA+B,oEAAoE,sCAAsC,gDAAgD,iDAAiD,YAAY,MAAM,iDAAiD,WAAW,SAAS,8CAA8C,sCAAsC,gBAAgB,UAAU,gGAAgG,kDAAkD,sGAAsG,iBAAiB,WAAW,uCAAuC,gFAAgF,iCAAiC,8BAA8B,oGAAoG,kHAAkH,6BAA6B,4CAA4C,WAAW,mGAAmG,oDAAoD,iCAAiC,gCAAgC,kCAAkC,+BAA+B,4DAA4D,gGAAgG,+DAA+D,iCAAiC,4DAA4D,6CAA6C,qCAAqC,WAAW,qDAAqD,uEAAuE,0DAA0D,4DAA4D,yDAAyD,2CAA2C,8BAA8B,iCAAiC,8BAA8B,+BAA+B,6CAA6C,gCAAgC,WAAW,+CAA+C,wFAAwF,gFAAgF,+DAA+D,yCAAyC,0DAA0D,wGAAwG,gHAAgH,YAAY,MAAM,sIAAsI,qJAAqJ,WAAW,4FAA4F,6EAA6E,uGAAuG,8DAA8D,WAAW,qIAAqI,4CAA4C,4CAA4C,0CAA0C,6BAA6B,6BAA6B,WAAW,0BAA0B,UAAU,oFAAoF,6CAA6C,yCAAyC,4FAA4F,6FAA6F,6CAA6C,SAAS,6CAA6C,wCAAwC,4CAA4C,mDAAmD,6CAA6C,SAAS,6CAA6C,oEAAoE,8CAA8C,6CAA6C,kIAAkI,cAAc,iJAAiJ,YAAY,6BAA6B,sBAAsB,SAAS,uEAAuE,iDAAiD,4DAA4D,0BAA0B,mCAAmC,yCAAyC,wCAAwC,4CAA4C,eAAe,cAAc,6BAA6B,oFAAoF,4CAA4C,eAAe,cAAc,gCAAgC,yCAAyC,cAAc,4CAA4C,kCAAkC,uHAAuH,eAAe,wFAAwF,cAAc,+DAA+D,2CAA2C,yCAAyC,eAAe,oFAAoF,oCAAoC,2HAA2H,iBAAiB,wDAAwD,6CAA6C,kDAAkD,+CAA+C,sDAAsD,OAAO,QAAQ,4CAA4C,sEAAsE,mEAAmE,mGAAmG,qBAAqB,mBAAmB,kBAAkB,8BAA8B,yFAAyF,iBAAiB,eAAe,aAAa,WAAW,yCAAyC,gDAAgD,OAAO,QAAQ,gEAAgE,WAAW,SAAS,+EAA+E,kDAAkD,OAAO,QAAQ,6CAA6C,2CAA2C,6CAA6C,iGAAiG,uCAAuC,yCAAyC,2CAA2C,2CAA2C,oDAAoD,QAAQ,QAAQ,2CAA2C,6DAA6D,8CAA8C,4CAA4C,2CAA2C,8CAA8C,gDAAgD,8GAA8G,oFAAoF,iBAAiB,eAAe,cAAc,MAAM,yCAAyC,+EAA+E,aAAa,WAAW,SAAS,mFAAmF,mFAAmF,mGAAmG,sEAAsE,iDAAiD,wFAAwF,uDAAuD,4EAA4E,yCAAyC,+DAA+D,YAAY,MAAM,6FAA6F,WAAW,kFAAkF,SAAS,wDAAwD,8DAA8D,oKAAoK,yEAAyE,mDAAmD,iCAAiC,wCAAwC,+FAA+F,YAAY,mCAAmC,+FAA+F,YAAY,+CAA+C,0DAA0D,YAAY,MAAM,wEAAwE,WAAW,gCAAgC,wCAAwC,4DAA4D,2CAA2C,kNAAkN,cAAc,MAAM,2CAA2C,iMAAiM,aAAa,kEAAkE,2GAA2G,iDAAiD,qCAAqC,WAAW,0DAA0D,wCAAwC,kDAAkD,6BAA6B,2BAA2B,QAAQ,kEAAkE,qDAAqD,eAAe,aAAa,WAAW,wCAAwC,kDAAkD,6BAA6B,2BAA2B,QAAQ,kEAAkE,qDAAqD,eAAe,aAAa,WAAW,4DAA4D,gIAAgI,uEAAuE,yEAAyE,sDAAsD,WAAW,uCAAuC,iHAAiH,kCAAkC,yIAAyI,sEAAsE,wDAAwD,gEAAgE,0DAA0D,8DAA8D,oFAAoF,wFAAwF,oEAAoE,0EAA0E,sEAAsE,4EAA4E,kFAAkF,mKAAmK,yDAAyD,SAAS,8DAA8D,gCAAgC,8DAA8D,mCAAmC,uEAAuE,uHAAuH,2VAA2V,aAAa,WAAW,iDAAiD,6DAA6D,0CAA0C,cAAc,4DAA4D,0CAA0C,cAAc,oFAAoF,0CAA0C,cAAc,8NAA8N,0CAA0C,aAAa,WAAW,uCAAuC,kDAAkD,uCAAuC,WAAW,qCAAqC,oCAAoC,kCAAkC,0JAA0J,sDAAsD,kCAAkC,iCAAiC,+BAA+B,WAAW,qDAAqD,6CAA6C,mCAAmC,WAAW,8DAA8D,oFAAoF,wDAAwD,0HAA0H,aAAa,mJAAmJ,iEAAiE,qPAAqP,sEAAsE,iDAAiD,2RAA2R,0DAA0D,4CAA4C,6GAA6G,eAAe,aAAa,+PAA+P,kFAAkF,aAAa,WAAW,6PAA6P,gEAAgE,qEAAqE,2CAA2C,6BAA6B,yCAAyC,uDAAuD,2DAA2D,ygBAAygB,mFAAmF,2CAA2C,0EAA0E,qFAAqF,6HAA6H,uDAAuD,mDAAmD,gDAAgD,iBAAiB,gFAAgF,sFAAsF,gBAAgB,MAAM,wEAAwE,eAAe,aAAa,WAAW,kCAAkC,yFAAyF,2FAA2F,oCAAoC,4ZAA4Z,aAAa,mGAAmG,oDAAoD,aAAa,iDAAiD,4DAA4D,cAAc,4CAA4C,4DAA4D,2DAA2D,cAAc,0CAA0C,4DAA4D,kDAAkD,4DAA4D,gBAAgB,MAAM,6DAA6D,eAAe,cAAc,6CAA6C,4DAA4D,sDAAsD,gEAAgE,gBAAgB,MAAM,gEAAgE,eAAe,cAAc,0CAA0C,4DAA4D,yDAAyD,cAAc,6CAA6C,4DAA4D,4DAA4D,cAAc,2CAA2C,4DAA4D,0DAA0D,cAAc,0CAA0C,0DAA0D,oDAAoD,4DAA4D,eAAe,cAAc,uCAAuC,4DAA4D,cAAc,uCAAuC,sDAAsD,wDAAwD,aAAa,oMAAoM,uGAAuG,uGAAuG,WAAW,8GAA8G,wEAAwE,sEAAsE,yBAAyB,SAAS,4GAA4G,oDAAoD,iCAAiC,oDAAoD,WAAW,oCAAoC,2GAA2G,WAAW,+BAA+B,8CAA8C,WAAW,oCAAoC,wDAAwD,WAAW,uCAAuC,8DAA8D,WAAW,kCAAkC,oDAAoD,yeAAye,gEAAgE,oEAAoE,WAAW,oCAAoC,wDAAwD,wEAAwE,WAAW,iCAAiC,kDAAkD,kEAAkE,WAAW,6NAA6N,+BAA+B,sCAAsC,YAAY,kCAAkC,8CAA8C,YAAY,sCAAsC,kDAAkD,YAAY,gCAAgC,4CAA4C,YAAY,8BAA8B,0CAA0C,YAAY,mCAAmC,+CAA+C,YAAY,mCAAmC,+CAA+C,YAAY,+BAA+B,2CAA2C,YAAY,kCAAkC,8CAA8C,WAAW,2CAA2C,uFAAuF,8CAA8C,aAAa,yDAAyD,6CAA6C,2CAA2C,+CAA+C,2CAA2C,uHAAuH,aAAa,iEAAiE,WAAW,SAAS,4DAA4D,kDAAkD,kDAAkD,SAAS,4DAA4D,sDAAsD,wEAAwE,8CAA8C,SAAS,8DAA8D,kDAAkD,kDAAkD,0DAA0D,6CAA6C,4CAA4C,wCAAwC,2DAA2D,+CAA+C,6CAA6C,iDAAiD,6CAA6C,yHAAyH,aAAa,mEAAmE,WAAW,SAAS,sDAAsD,8CAA8C,4BAA4B,8CAA8C,0CAA0C,YAAY,2BAA2B,oDAAoD,WAAW,SAAS,+DAA+D,uCAAuC,8DAA8D,WAAW,SAAS,6DAA6D,sDAAsD,yEAAyE,oEAAoE,8DAA8D,WAAW,mCAAmC,sDAAsD,wDAAwD,WAAW,qCAAqC,0DAA0D,kEAAkE,WAAW,2CAA2C,sEAAsE,wEAAwE,sEAAsE,WAAW,SAAS,4DAA4D,qDAAqD,uCAAuC,8DAA8D,WAAW,SAAS,gEAAgE,wDAAwD,sDAAsD,wCAAwC,gEAAgE,WAAW,wCAAwC,gEAAgE,WAAW,uCAAuC,8DAA8D,WAAW,mCAAmC,sDAAsD,wDAAwD,WAAW,qCAAqC,0DAA0D,kEAAkE,WAAW,2CAA2C,sEAAsE,wEAAwE,sEAAsE,WAAW,kCAAkC,uDAAuD,8FAA8F,WAAW,SAAS,gEAAgE,wDAAwD,wEAAwE,wDAAwD,SAAS,6DAA6D,2CAA2C,sEAAsE,wEAAwE,sEAAsE,WAAW,SAAS,gEAAgE,2CAA2C,sEAAsE,wEAAwE,sEAAsE,WAAW,8EAA8E,4DAA4D,0DAA0D,SAAS,8DAA8D,mCAAmC,sDAAsD,wDAAwD,WAAW,qCAAqC,0DAA0D,kEAAkE,WAAW,2CAA2C,sEAAsE,wEAAwE,sEAAsE,WAAW,SAAS,uJAAuJ,yDAAyD,yDAAyD,iDAAiD,gDAAgD,oDAAoD,sDAAsD,SAAS,oGAAoG,wCAAwC,0EAA0E,UAAU,wDAAwD,8CAA8C,0DAA0D,4JAA4J,WAAW,iCAAiC,6BAA6B,SAAS,iDAAiD,4CAA4C,yCAAyC,6BAA6B,iHAAiH,2DAA2D,+BAA+B,iJAAiJ,4BAA4B,eAAe,wCAAwC,aAAa,mDAAmD,YAAY,SAAS,KAAK,yCAAyC,6BAA6B,uDAAuD,6BAA6B,4GAA4G,0BAA0B,aAAa,mDAAmD,YAAY,SAAS,KAAK,6CAA6C,6BAA6B,2DAA2D,yHAAyH,+BAA+B,wJAAwJ,4BAA4B,eAAe,wCAAwC,aAAa,iSAAiS,wLAAwL,cAAc,MAAM,uIAAuI,aAAa,YAAY,SAAS,KAAK,4CAA4C,sCAAsC,UAAU,0DAA0D,8CAA8C,kGAAkG,uDAAuD,WAAW,iCAAiC,2BAA2B,+BAA+B,uFAAuF,yDAAyD,8EAA8E,0BAA0B,cAAc,MAAM,+CAA+C,aAAa,2DAA2D,uDAAuD,yDAAyD,YAAY,MAAM,6EAA6E,yEAAyE,6CAA6C,WAAW,sDAAsD,gEAAgE,4CAA4C,WAAW,6CAA6C,yCAAyC,oDAAoD,yBAAyB,2EAA2E,8MAA8M,WAAW,UAAU,8FAA8F,yEAAyE,wHAAwH,iBAAiB,WAAW,8EAA8E,8BAA8B,gCAAgC,wDAAwD,kEAAkE,6BAA6B,aAAa,iBAAiB,iDAAiD,+CAA+C,2CAA2C,kJAAkJ,6IAA6I,qBAAqB,eAAe,gdAAgd,uJAAuJ,qBAAqB,eAAe,iGAAiG,+OAA+O,8HAA8H,iBAAiB,gBAAgB,MAAM,8IAA8I,eAAe,cAAc,SAAS,8BAA8B,4EAA4E,eAAe,aAAa,WAAW,UAAU,OAAO,uJAAuJ,uBAAuB,wCAAwC,mEAAmE,OAAO,yCAAyC,6CAA6C,gEAAgE,QAAQ,0DAA0D,gBAAgB,gGAAgG,QAAQ,qJAAqJ,uBAAuB,wCAAwC,sDAAsD,oDAAoD,OAAO,iCAAiC,yCAAyC,mEAAmE,QAAQ,sDAAsD,gBAAgB,4GAA4G,QAAQ,kFAAkF,8BAA8B,4BAA4B,+BAA+B,sBAAsB,mCAAmC,gCAAgC,iCAAiC,6EAA6E,yEAAyE,kEAAkE,wFAAwF,iEAAiE,wGAAwG,8CAA8C,wDAAwD,sBAAsB,SAAS,oCAAoC,kEAAkE,kGAAkG,qEAAqE,sBAAsB,SAAS,QAAQ,EAAE,yLAAyL,8BAA8B,6BAA6B,4CAA4C,4CAA4C,sCAAsC,+DAA+D,SAAS,OAAO,iFAAiF,4FAA4F,uDAAuD,4DAA4D,gEAAgE,yDAAyD,OAAO,QAAQ,2DAA2D,WAAW,sBAAsB,SAAS,8EAA8E,+CAA+C,mDAAmD,iDAAiD,iEAAiE,gEAAgE,mEAAmE,iCAAiC,oeAAoe,EAAE,SAAS,iPAAiP,6CAA6C,kBAAkB,+CAA+C,+CAA+C,uBAAuB,QAAQ,QAAQ,yCAAyC,oEAAoE,kEAAkE,4DAA4D,6EAA6E,WAAW,SAAS,QAAQ,EAAE,uFAAuF,gLAAgL,oDAAoD,8BAA8B,qCAAqC,2CAA2C,sBAAsB,0BAA0B,yBAAyB,0BAA0B,qCAAqC,OAAO,qEAAqE,0DAA0D,qDAAqD,2DAA2D,qDAAqD,wCAAwC,4BAA4B,wCAAwC,oBAAoB,QAAQ,sJAAsJ,8BAA8B,6BAA6B,qFAAqF,OAAO,8EAA8E,mFAAmF,6CAA6C,0CAA0C,uCAAuC,4DAA4D,oEAAoE,6EAA6E,8DAA8D,4DAA4D,0FAA0F,6EAA6E,gFAAgF,8BAA8B,wIAAwI,EAAE,YAAY,SAAS,iCAAiC,oEAAoE,SAAS,QAAQ,EAAE,mLAAmL,8BAA8B,0BAA0B,wCAAwC,iBAAiB,uDAAuD,QAAQ,EAAE,OAAO,2EAA2E,4DAA4D,8DAA8D,qCAAqC,8CAA8C,OAAO,QAAQ,oCAAoC,kEAAkE,WAAW,sBAAsB,SAAS,kDAAkD,qDAAqD,0CAA0C,mCAAmC,2BAA2B,mBAAmB,QAAQ,oDAAoD,oBAAoB,aAAa,WAAW,iCAAiC,qCAAqC,EAAE,6BAA6B,SAAS,sDAAsD,mCAAmC,8CAA8C,OAAO,QAAQ,oDAAoD,oBAAoB,aAAa,WAAW,wCAAwC,SAAS,iCAAiC,6CAA6C,4DAA4D,qEAAqE,6EAA6E,mFAAmF,YAAY,SAAS,kCAAkC,iCAAiC,+BAA+B,4CAA4C,qCAAqC,sCAAsC,6DAA6D,yDAAyD,iDAAiD,gDAAgD,kDAAkD,OAAO,QAAQ,yDAAyD,yDAAyD,kDAAkD,kBAAkB,MAAM,wBAAwB,iBAAiB,eAAe,sBAAsB,OAAO,QAAQ,mDAAmD,eAAe,aAAa,YAAY,SAAS,sCAAsC,kEAAkE,kCAAkC,mCAAmC,8CAA8C,OAAO,QAAQ,oCAAoC,sCAAsC,sFAAsF,EAAE,WAAW,sBAAsB,SAAS,QAAQ,EAAE,uQAAuQ,0DAA0D,sCAAsC,qEAAqE,8GAA8G,mCAAmC,UAAU,MAAM,4DAA4D,wDAAwD,YAAY,MAAM,+EAA+E,mCAAmC,qDAAqD,QAAQ,QAAQ,sDAAsD,aAAa,WAAW,SAAS,OAAO,0CAA0C,wCAAwC,iCAAiC,mDAAmD,QAAQ,QAAQ,wCAAwC,oCAAoC,gEAAgE,aAAa,8CAA8C,WAAW,SAAS,4BAA4B,0BAA0B,gGAAgG,QAAQ,QAAQ,mCAAmC,yBAAyB,oEAAoE,aAAa,WAAW,uHAAuH,QAAQ,QAAQ,mCAAmC,yBAAyB,wDAAwD,kEAAkE,uDAAuD,gBAAgB,MAAM,qDAAqD,eAAe,kFAAkF,aAAa,WAAW,SAAS,gCAAgC,2CAA2C,2CAA2C,oCAAoC,mCAAmC,+CAA+C,+CAA+C,6CAA6C,6FAA6F,QAAQ,QAAQ,kKAAkK,yEAAyE,yDAAyD,aAAa,8CAA8C,6CAA6C,aAAa,YAAY,UAAU,gCAAgC,+DAA+D,SAAS,QAAQ,EAAE,kLAAkL,8BAA8B,2BAA2B,OAAO,4EAA4E,sDAAsD,EAAE,6MAA6M,8CAA8C,kCAAkC,mCAAmC,sCAAsC,6CAA6C,qCAAqC,2CAA2C,gDAAgD,oCAAoC,OAAO,+EAA+E,6FAA6F,sCAAsC,kBAAkB,qEAAqE,iIAAiI,QAAQ,QAAQ,+CAA+C,yEAAyE,+BAA+B,kEAAkE,iDAAiD,oDAAoD,6EAA6E,aAAa,sGAAsG,QAAQ,QAAQ,+CAA+C,uHAAuH,4GAA4G,gBAAgB,MAAM,2GAA2G,eAAe,aAAa,WAAW,mLAAmL,uBAAuB,SAAS,kDAAkD,mCAAmC,2CAA2C,2CAA2C,8CAA8C,0CAA0C,WAAW,6CAA6C,wDAAwD,SAAS,4BAA4B,+BAA+B,SAAS,4CAA4C,uBAAuB,4DAA4D,yBAAyB,sCAAsC,QAAQ,sDAAsD,iDAAiD,yCAAyC,2CAA2C,gBAAgB,MAAM,sCAAsC,yCAAyC,aAAa,YAAY,6DAA6D,oCAAoC,iEAAiE,yBAAyB,sBAAsB,QAAQ,2CAA2C,yCAAyC,yCAAyC,yCAAyC,kDAAkD,yCAAyC,4CAA4C,gBAAgB,MAAM,uCAAuC,yCAAyC,kEAAkE,aAAa,WAAW,SAAS,gDAAgD,+DAA+D,+CAA+C,kEAAkE,YAAY,0CAA0C,iEAAiE,YAAY,MAAM,yFAAyF,WAAW,SAAS,6BAA6B,mFAAmF,SAAS,QAAQ,EAAE,iIAAiI,6IAA6I,uDAAuD,8BAA8B,wCAAwC,2CAA2C,2BAA2B,6BAA6B,8BAA8B,4BAA4B,qCAAqC,OAAO,wEAAwE,gEAAgE,6DAA6D,8DAA8D,qDAAqD,wCAAwC,0CAA0C,oCAAoC,sCAAsC,oBAAoB,QAAQ,2GAA2G,2BAA2B,4HAA4H,sDAAsD,SAAS,8BAA8B,2BAA2B,iFAAiF,mFAAmF,kCAAkC,EAAE,OAAO,4EAA4E,+EAA+E,4CAA4C,4BAA4B,kCAAkC,4DAA4D,oDAAoD,kDAAkD,yCAAyC,6CAA6C,2IAA2I,mDAAmD,6CAA6C,6EAA6E,kEAAkE,kEAAkE,uCAAuC,mCAAmC,2CAA2C,uCAAuC,6DAA6D,8CAA8C,yCAAyC,iDAAiD,sDAAsD,qCAAqC,0CAA0C,yDAAyD,OAAO,aAAa,uCAAuC,yCAAyC,uDAAuD,mDAAmD,+FAA+F,uDAAuD,6DAA6D,gIAAgI,wFAAwF,oCAAoC,kZAAkZ,EAAE,iBAAiB,gBAAgB,MAAM,+DAA+D,OAAO,aAAa,uDAAuD,uDAAuD,+FAA+F,uDAAuD,6DAA6D,gIAAgI,wFAAwF,oCAAoC,kZAAkZ,EAAE,iBAAiB,eAAe,cAAc,iCAAiC,+CAA+C,6CAA6C,+BAA+B,oBAAoB,aAAa,iHAAiH,qDAAqD,2DAA2D,8HAA8H,sFAAsF,kCAAkC,gYAAgY,EAAE,eAAe,aAAa,YAAY,SAAS,iCAAiC,mFAAmF,SAAS,QAAQ,EAAE,6GAA6G,8CAA8C,mCAAmC,OAAO,gFAAgF,sEAAsE,EAAE,iHAAiH,8CAA8C,+BAA+B,OAAO,4EAA4E,+DAA+D,EAAE,iIAAiI,2JAA2J,oDAAoD,8BAA8B,qCAAqC,2CAA2C,wBAAwB,sBAAsB,kCAAkC,4BAA4B,qCAAqC,OAAO,qEAAqE,0DAA0D,uDAAuD,2DAA2D,qDAAqD,wCAAwC,8BAA8B,gCAAgC,oDAAoD,oBAAoB,QAAQ,gHAAgH,8BAA8B,6BAA6B,iFAAiF,gFAAgF,kCAAkC,EAAE,OAAO,8EAA8E,mFAAmF,4CAA4C,4BAA4B,kCAAkC,4DAA4D,8BAA8B,uCAAuC,6CAA6C,4DAA4D,2IAA2I,mDAAmD,6CAA6C,qCAAqC,6EAA6E,kEAAkE,kEAAkE,oGAAoG,iEAAiE,uCAAuC,gDAAgD,sEAAsE,4DAA4D,sEAAsE,yDAAyD,iFAAiF,oFAAoF,kCAAkC,0PAA0P,EAAE,eAAe,aAAa,8CAA8C,yCAAyC,iDAAiD,sDAAsD,qCAAqC,0CAA0C,sDAAsD,QAAQ,QAAQ,uCAAuC,yDAAyD,2CAA2C,iBAAiB,gBAAgB,MAAM,2DAA2D,OAAO,QAAQ,yDAAyD,2CAA2C,iBAAiB,eAAe,cAAc,MAAM,+CAA+C,oDAAoD,OAAO,QAAQ,8CAA8C,eAAe,aAAa,YAAY,SAAS,iCAAiC,mFAAmF,SAAS,QAAQ,EAAE,kFAAkF,8BAA8B,4BAA4B,OAAO,6EAA6E,wDAAwD,EAAE,uKAAuK,2GAA2G,qCAAqC,6EAA6E,6BAA6B,qEAAqE,iCAAiC,SAAS,gEAAgE,OAAO,mFAAmF,4FAA4F,iCAAiC,8DAA8D,oCAAoC,WAAW,SAAS,QAAQ,EAAE,gNAAgN,oHAAoH,uBAAuB,+BAA+B,6BAA6B,iIAAiI,yIAAyI,OAAO,uEAAuE,gEAAgE,6DAA6D,qNAAqN,6DAA6D,wEAAwE,gHAAgH,SAAS,qFAAqF,2FAA2F,0GAA0G,uBAAuB,+BAA+B,6EAA6E,2EAA2E,2BAA2B,oCAAoC,OAAO,kEAAkE,sDAAsD,iDAAiD,2JAA2J,oCAAoC,wCAAwC,2CAA2C,sDAAsD,qCAAqC,kBAAkB,wCAAwC,iBAAiB,0GAA0G,oHAAoH,yCAAyC,OAAO,QAAQ,kCAAkC,yBAAyB,OAAO,QAAQ,wCAAwC,kDAAkD,kDAAkD,+EAA+E,gDAAgD,iDAAiD,iCAAiC,uCAAuC,eAAe,aAAa,WAAW,8DAA8D,6BAA6B,mDAAmD,wDAAwD,mDAAmD,wDAAwD,WAAW,UAAU,mDAAmD,wCAAwC,gCAAgC,2BAA2B,iCAAiC,0CAA0C,yFAAyF,mCAAmC,mCAAmC,wCAAwC,2BAA2B,mDAAmD,EAAE,aAAa,6HAA6H,QAAQ,QAAQ,kCAAkC,kCAAkC,gCAAgC,sDAAsD,OAAO,UAAU,6BAA6B,OAAO,QAAQ,gDAAgD,0DAA0D,sDAAsD,mFAAmF,oDAAoD,qDAAqD,qCAAqC,uCAAuC,mBAAmB,iBAAiB,eAAe,aAAa,kEAAkE,+BAA+B,+DAA+D,0DAA0D,+DAA+D,0DAA0D,aAAa,YAAY,MAAM,6FAA6F,qDAAqD,OAAO,QAAQ,2BAA2B,OAAO,QAAQ,6MAA6M,6DAA6D,4DAA4D,mDAAmD,6DAA6D,4DAA4D,eAAe,aAAa,WAAW,SAAS,4GAA4G,OAAO,8EAA8E,gEAAgE,gUAAgU,8BAA8B,yCAAyC,2BAA2B,wEAAwE,wFAAwF,2BAA2B,OAAO,yEAAyE,kEAAkE,kGAAkG,oCAAoC,+CAA+C,2BAA2B,wEAAwE,2CAA2C,wBAAwB,uBAAuB,mBAAmB,0BAA0B,mCAAmC,mDAAmD,iDAAiD,iBAAiB,iFAAiF,qBAAqB,aAAa,QAAQ,6BAA6B,uBAAuB,aAAa,QAAQ,+BAA+B,uDAAuD,4CAA4C,uHAAuH,0CAA0C,oCAAoC,cAAc,MAAM,0CAA0C,oCAAoC,aAAa,iCAAiC,0CAA0C,oCAAoC,cAAc,MAAM,0CAA0C,oCAAoC,aAAa,4HAA4H,uDAAuD,8CAA8C,WAAW,SAAS,gDAAgD,YAAY,QAAQ,uBAAuB,YAAY,QAAQ,uCAAuC,yCAAyC,iDAAiD,6CAA6C,oEAAoE,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,qFAAqF,8EAA8E,gWAAgW,8BAA8B,yCAAyC,2BAA2B,yGAAyG,qGAAqG,2BAA2B,OAAO,yEAAyE,kEAAkE,+GAA+G,oCAAoC,+CAA+C,2BAA2B,yGAAyG,6BAA6B,2BAA2B,4DAA4D,wBAAwB,qFAAqF,4GAA4G,4DAA4D,4HAA4H,2FAA2F,2EAA2E,6BAA6B,uCAAuC,yBAAyB,MAAM,mCAAmC,0BAA0B,iEAAiE,gCAAgC,8BAA8B,8BAA8B,iHAAiH,oBAAoB,UAAU,+FAA+F,kDAAkD,kDAAkD,+EAA+E,WAAW,SAAS,mDAAmD,2CAA2C,qHAAqH,mBAAmB,sFAAsF,WAAW,QAAQ,wBAAwB,mDAAmD,iDAAiD,gCAAgC,yBAAyB,WAAW,QAAQ,4CAA4C,iCAAiC,gBAAgB,MAAM,8DAA8D,eAAe,aAAa,WAAW,8DAA8D,UAAU,QAAQ,yBAAyB,0BAA0B,QAAQ,0CAA0C,kCAAkC,8CAA8C,4CAA4C,wCAAwC,gBAAgB,MAAM,8CAA8C,gDAAgD,4CAA4C,eAAe,aAAa,WAAW,SAAS,yCAAyC,qCAAqC,0GAA0G,yBAAyB,UAAU,6CAA6C,2CAA2C,2CAA2C,wDAAwD,6CAA6C,2CAA2C,2CAA2C,WAAW,SAAS,gCAAgC,qCAAqC,2BAA2B,yBAAyB,UAAU,6CAA6C,2CAA2C,2CAA2C,0DAA0D,wDAAwD,oCAAoC,WAAW,uBAAuB,wBAAwB,SAAS,gCAAgC,2FAA2F,qBAAqB,UAAU,8EAA8E,qCAAqC,qCAAqC,6CAA6C,2CAA2C,mFAAmF,qDAAqD,mDAAmD,mDAAmD,aAAa,WAAW,SAAS,uCAAuC,4DAA4D,SAAS,oDAAoD,iCAAiC,4CAA4C,0CAA0C,0CAA0C,SAAS,+BAA+B,gCAAgC,8BAA8B,8BAA8B,uCAAuC,kCAAkC,gCAAgC,gCAAgC,kCAAkC,yBAAyB,kBAAkB,yFAAyF,uFAAuF,uFAAuF,4DAA4D,0DAA0D,0DAA0D,mEAAmE,0CAA0C,4CAA4C,0CAA0C,0CAA0C,WAAW,SAAS,2DAA2D,oDAAoD,0CAA0C,WAAW,2DAA2D,6DAA6D,WAAW,SAAS,kHAAkH,oDAAoD,SAAS,8EAA8E,0GAA0G,SAAS,OAAO,qFAAqF,8EAA8E,sNAAsN,8BAA8B,0CAA0C,2BAA2B,qDAAqD,mFAAmF,2BAA2B,OAAO,0EAA0E,oEAAoE,8FAA8F,4FAA4F,6EAA6E,iFAAiF,gDAAgD,2BAA2B,qDAAqD,OAAO,gGAAgG,gFAAgF,oNAAoN,8BAA8B,yCAAyC,2BAA2B,qDAAqD,kFAAkF,2BAA2B,OAAO,yEAAyE,kEAAkE,4FAA4F,+GAA+G,gIAAgI,iFAAiF,+CAA+C,2BAA2B,qDAAqD,OAAO,+FAA+F,8EAA8E,sNAAsN,8BAA8B,0CAA0C,2BAA2B,qDAAqD,mFAAmF,2BAA2B,OAAO,0EAA0E,oEAAoE,8FAA8F,2CAA2C,2MAA2M,mRAAmR,iFAAiF,gDAAgD,2BAA2B,qDAAqD,OAAO,gGAAgG,gFAAgF,oMAAoM,8BAA8B,2CAA2C,2BAA2B,qDAAqD,oFAAoF,2BAA2B,OAAO,2EAA2E,sEAAsE,gGAAgG,2CAA2C,oBAAoB,obAAob,whBAAwhB,iFAAiF,iDAAiD,2BAA2B,qDAAqD,OAAO,iGAAiG,kFAAkF,0cAA0c,8BAA8B,mCAAmC,2BAA2B,wJAAwJ,iGAAiG,6GAA6G,2EAA2E,4CAA4C,gDAAgD,4EAA4E,2BAA2B,OAAO,mEAAmE,sDAAsD,uHAAuH,oCAAoC,yCAAyC,2BAA2B,wJAAwJ,gDAAgD,2BAA2B,2CAA2C,+BAA+B,yEAAyE,mEAAmE,oCAAoC,wCAAwC,8DAA8D,iCAAiC,6BAA6B,4BAA4B,iBAAiB,2CAA2C,uBAAuB,mBAAmB,uBAAuB,0DAA0D,0DAA0D,iFAAiF,8EAA8E,sEAAsE,2DAA2D,uBAAuB,qBAAqB,QAAQ,iCAAiC,WAAW,sUAAsU,wJAAwJ,6DAA6D,SAAS,uCAAuC,8IAA8I,6FAA6F,sCAAsC,yFAAyF,qBAAqB,QAAQ,qDAAqD,oCAAoC,oCAAoC,sEAAsE,+CAA+C,+CAA+C,6BAA6B,yDAAyD,oEAAoE,6CAA6C,6CAA6C,0DAA0D,WAAW,SAAS,oCAAoC,uBAAuB,sBAAsB,QAAQ,yBAAyB,qBAAqB,QAAQ,qEAAqE,2DAA2D,mDAAmD,2DAA2D,4DAA4D,oCAAoC,aAAa,WAAW,SAAS,gCAAgC,uBAAuB,sBAAsB,QAAQ,yBAAyB,qBAAqB,QAAQ,yCAAyC,sCAAsC,qCAAqC,aAAa,WAAW,SAAS,OAAO,+EAA+E,kEAAkE,2RAA2R,8BAA8B,wCAAwC,2BAA2B,2JAA2J,oJAAoJ,sHAAsH,2BAA2B,OAAO,wEAAwE,gEAAgE,+HAA+H,oCAAoC,8CAA8C,2BAA2B,2JAA2J,6BAA6B,yBAAyB,4DAA4D,yDAAyD,iBAAiB,iBAAiB,2CAA2C,wBAAwB,uBAAuB,mBAAmB,4CAA4C,mCAAmC,iCAAiC,+BAA+B,6BAA6B,8BAA8B,4BAA4B,4BAA4B,kEAAkE,sBAAsB,QAAQ,0KAA0K,iTAAiT,+DAA+D,yEAAyE,+BAA+B,+BAA+B,+BAA+B,sFAAsF,sBAAsB,uBAAuB,qBAAqB,QAAQ,4PAA4P,0CAA0C,wCAAwC,kOAAkO,oDAAoD,oDAAoD,0DAA0D,2KAA2K,yDAAyD,6DAA6D,yCAAyC,WAAW,SAAS,gDAAgD,sBAAsB,QAAQ,uBAAuB,qBAAqB,QAAQ,yFAAyF,yDAAyD,iDAAiD,yDAAyD,wDAAwD,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,mJAAmJ,iCAAiC,+BAA+B,gCAAgC,qCAAqC,sDAAsD,oDAAoD,wDAAwD,SAAS,OAAO,oFAAoF,4EAA4E,kPAAkP,8BAA8B,oCAAoC,2BAA2B,kJAAkJ,iHAAiH,2BAA2B,OAAO,oEAAoE,wDAAwD,sHAAsH,oCAAoC,0CAA0C,2BAA2B,kJAAkJ,6BAA6B,yBAAyB,yDAAyD,2DAA2D,+BAA+B,2CAA2C,wBAAwB,uBAAuB,mBAAmB,8DAA8D,iCAAiC,iCAAiC,iBAAiB,kEAAkE,qBAAqB,QAAQ,uBAAuB,sBAAsB,QAAQ,8CAA8C,mDAAmD,8FAA8F,uEAAuE,0CAA0C,0DAA0D,mEAAmE,4CAA4C,0DAA0D,yDAAyD,6DAA6D,yCAAyC,WAAW,SAAS,gDAAgD,qBAAqB,QAAQ,uBAAuB,sBAAsB,QAAQ,8EAA8E,8DAA8D,0DAA0D,kDAAkD,wDAAwD,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,gFAAgF,oEAAoE,iJAAiJ,0DAA0D,yBAAyB,0NAA0N,8CAA8C,oDAAoD,0FAA0F,iFAAiF,+DAA+D,oCAAoC,kCAAkC,+BAA+B,cAAc,YAAY,4BAA4B,8BAA8B,qCAAqC,qCAAqC,qCAAqC,qCAAqC,aAAa,yKAAyK,oDAAoD,WAAW,yEAAyE,2BAA2B,SAAS,QAAQ,+JAA+J,oBAAoB,0EAA0E,2BAA2B,SAAS,kEAAkE,UAAU,MAAM,+BAA+B,YAAY,kEAAkE,SAAS,kDAAkD,6BAA6B,yBAAyB,SAAS,oBAAoB,OAAO,0FAA0F,oCAAoC,+BAA+B,6BAA6B,YAAY,wBAAwB,4FAA4F,4BAA4B,2BAA2B,oCAAoC,uBAAuB,YAAY,MAAM,uBAAuB,WAAW,UAAU,6BAA6B,mBAAmB,OAAO,mKAAmK,4BAA4B,qHAAqH,mCAAmC,iGAAiG,0BAA0B,wBAAwB,mFAAmF,4EAA4E,wCAAwC,yCAAyC,8BAA8B,iGAAiG,2BAA2B,qBAAqB,WAAW,qBAAqB,yHAAyH,gFAAgF,0FAA0F,mGAAmG,wBAAwB,kEAAkE,wEAAwE,2FAA2F,wBAAwB,sEAAsE,aAAa,kBAAkB,WAAW,SAAS,OAAO,wGAAwG,8DAA8D,kDAAkD,kIAAkI,kCAAkC,8GAA8G,yBAAyB,WAAW,qBAAqB,SAAS,oBAAoB,OAAO,wDAAwD,8DAA8D,kDAAkD,oDAAoD,wXAAwX,uDAAuD,0HAA0H,oGAAoG,oCAAoC,oLAAoL,oBAAoB,SAAS,2EAA2E,oCAAoC,oLAAoL,sBAAsB,SAAS,oBAAoB,OAAO,6IAA6I,sBAAsB,YAAY,0CAA0C,sHAAsH,wCAAwC,sCAAsC,sCAAsC,oEAAoE,+BAA+B,0BAA0B,WAAW,qBAAqB,UAAU,sBAAsB,iBAAiB,OAAO,oJAAoJ,4FAA4F,YAAY,8BAA8B,kCAAkC,2DAA2D,oGAAoG,mGAAmG,0CAA0C,6GAA6G,mEAAmE,mBAAmB,aAAa,uBAAuB,WAAW,qBAAqB,UAAU,sBAAsB,OAAO,+JAA+J,iDAAiD,+CAA+C,SAAS,QAAQ,yCAAyC,qEAAqE,0DAA0D,sDAAsD,0CAA0C,SAAS,+BAA+B,gEAAgE,kBAAkB,QAAQ,iDAAiD,8DAA8D,SAAS,yBAAyB,OAAO,iCAAiC,yBAAyB,OAAO,8IAA8I,sDAAsD,0BAA0B,kDAAkD,oCAAoC,SAAS,OAAO,uIAAuI,oGAAoG,0FAA0F,wFAAwF,kEAAkE,iFAAiF,sCAAsC,qBAAqB,+BAA+B,2CAA2C,mDAAmD,eAAe,8CAA8C,aAAa,WAAW,qBAAqB,UAAU,0BAA0B,+BAA+B,wCAAwC,+BAA+B,mHAAmH,kEAAkE,sLAAsL,mBAAmB,8BAA8B,2JAA2J,uDAAuD,iHAAiH,oBAAoB,yBAAyB,aAAa,WAAW,qBAAqB,SAAS,iBAAiB,OAAO,oGAAoG,sBAAsB,YAAY,4EAA4E,yBAAyB,yBAAyB,mBAAmB,UAAU,sBAAsB,6BAA6B,qBAAqB,wBAAwB,OAAO,sKAAsK,kEAAkE,YAAY,mBAAmB,oBAAoB,oBAAoB,sBAAsB,uBAAuB,yBAAyB,gBAAgB,oBAAoB,yBAAyB,YAAY,QAAQ,uBAAuB,wBAAwB,6BAA6B,aAAa,2BAA2B,uDAAuD,0EAA0E,sBAAsB,0BAA0B,uBAAuB,gBAAgB,MAAM,sBAAsB,0BAA0B,uBAAuB,eAAe,yCAAyC,0BAA0B,6BAA6B,qBAAqB,aAAa,kBAAkB,WAAW,4BAA4B,oBAAoB,UAAU,wBAAwB,oBAAoB,OAAO,wIAAwI,mHAAmH,yCAAyC,4CAA4C,0CAA0C,0CAA0C,0CAA0C,4CAA4C,0CAA0C,0CAA0C,0CAA0C,8BAA8B,OAAO,sFAAsF,wCAAwC,YAAY,+CAA+C,mBAAmB,UAAU,sBAAsB,wBAAwB,OAAO,yHAAyH,kNAAkN,OAAO,kIAAkI,oKAAoK,OAAO,kEAAkE,6EAA6E,OAAO,uEAAuE,8CAA8C,OAAO,qFAAqF,yHAAyH,kIAAkI,OAAO,8GAA8G,kBAAkB,YAAY,qIAAqI,wBAAwB,WAAW,qBAAqB,UAAU,kBAAkB,qBAAqB,OAAO,wGAAwG,2KAA2K,OAAO,mHAAmH,uGAAuG,YAAY,qKAAqK,8BAA8B,WAAW,qBAAqB,UAAU,kBAAkB,sBAAsB,OAAO,kDAAkD,oEAAoE,mIAAmI,0HAA0H,mBAAmB,iBAAiB,qBAAqB,mBAAmB,qBAAqB,mBAAmB,qBAAqB,mBAAmB,kBAAkB,OAAO,8IAA8I,oCAAoC,uBAAuB,qBAAqB,mBAAmB,UAAU,MAAM,6BAA6B,sBAAsB,2BAA2B,sBAAsB,SAAS,iBAAiB,OAAO,gCAAgC,6BAA6B,2BAA2B,+CAA+C,6CAA6C,OAAO,gCAAgC,8DAA8D,8CAA8C,iBAAiB,mFAAmF,uBAAuB,kDAAkD,qEAAqE,wBAAwB,+EAA+E,OAAO,oDAAoD,oBAAoB,4CAA4C,SAAS,YAAY,+EAA+E,cAAc,SAAS,mBAAmB,OAAO,gGAAgG,oFAAoF,iCAAiC,oBAAoB,sCAAsC,OAAO,YAAY,mFAAmF,WAAW,yBAAyB,SAAS,wCAAwC,4CAA4C,SAAS,wDAAwD,8CAA8C,kCAAkC,mEAAmE,2BAA2B,aAAa,WAAW,oDAAoD,6BAA6B,oBAAoB,QAAQ,8CAA8C,4CAA4C,aAAa,WAAW,6BAA6B,yFAAyF,gDAAgD,mGAAmG,wCAAwC,qDAAqD,yCAAyC,uBAAuB,kBAAkB,QAAQ,0CAA0C,yCAAyC,6CAA6C,WAAW,kFAAkF,uCAAuC,sBAAsB,UAAU,sDAAsD,WAAW,uBAAuB,SAAS,QAAQ,qJAAqJ,+tBAA+tB,kFAAkF,8BAA8B,sCAAsC,2BAA2B,uDAAuD,gFAAgF,2BAA2B,OAAO,sEAAsE,4DAA4D,uFAAuF,oDAAoD,iBAAiB,SAAS,oCAAoC,4CAA4C,+DAA+D,6CAA6C,oCAAoC,oMAAoM,8DAA8D,OAAO,kFAAkF,wEAAwE,+DAA+D,kEAAkE,yGAAyG,sDAAsD,uFAAuF,wCAAwC,kGAAkG,gBAAgB,uFAAuF,QAAQ,mFAAmF,+BAA+B,wCAAwC,yBAAyB,QAAQ,QAAQ,kCAAkC,wCAAwC,SAAS,8CAA8C,gGAAgG,oFAAoF,QAAQ,8EAA8E,wEAAwE,0CAA0C,sCAAsC,8BAA8B,6BAA6B,2EAA2E,gGAAgG,qGAAqG,8FAA8F,6FAA6F,qGAAqG,oEAAoE,8CAA8C,4CAA4C,uLAAuL,oDAAoD,0BAA0B,4DAA4D,+BAA+B,8BAA8B,iPAAiP,+HAA+H,mCAAmC,+BAA+B,kCAAkC,SAAS,8EAA8E,4BAA4B,2BAA2B,sBAAsB,SAAS,6DAA6D,0CAA0C,+DAA+D,yCAAyC,oCAAoC,2DAA2D,wBAAwB,wCAAwC,6IAA6I,QAAQ,QAAQ,+BAA+B,oDAAoD,2CAA2C,aAAa,WAAW,SAAS,qEAAqE,sDAAsD,+GAA+G,QAAQ,QAAQ,6BAA6B,8CAA8C,SAAS,8CAA8C,sFAAsF,8DAA8D,SAAS,+FAA+F,uGAAuG,ybAAyb,oQAAoQ,gFAAgF,2EAA2E,6GAA6G,0DAA0D,mIAAmI,kFAAkF,qIAAqI,mEAAmE,qEAAqE,mEAAmE,2PAA2P,wHAAwH,iEAAiE,0LAA0L,qCAAqC,yDAAyD,cAAc,MAAM,yDAAyD,aAAa,YAAY,MAAM,2FAA2F,gEAAgE,gDAAgD,oCAAoC,eAAe,cAAc,MAAM,kDAAkD,oDAAoD,sCAAsC,iBAAiB,gBAAgB,MAAM,wEAAwE,sCAAsC,iBAAiB,eAAe,aAAa,iCAAiC,yEAAyE,mCAAmC,iCAAiC,kDAAkD,cAAc,MAAM,sEAAsE,iCAAiC,iCAAiC,sDAAsD,aAAa,WAAW,6EAA6E,SAAS,oCAAoC,qEAAqE,QAAQ,oBAAoB,gCAAgC,8BAA8B,gKAAgK,SAAS,wGAAwG,wCAAwC,QAAQ,QAAQ,6BAA6B,gCAAgC,iEAAiE,QAAQ,oBAAoB,kCAAkC,gCAAgC,mHAAmH,WAAW,kDAAkD,yEAAyE,SAAS,qFAAqF,mBAAmB,QAAQ,qCAAqC,OAAO,QAAQ,gCAAgC,yDAAyD,qDAAqD,uEAAuE,QAAQ,QAAQ,uEAAuE,qCAAqC,WAAW,mEAAmE,QAAQ,QAAQ,+BAA+B,iDAAiD,4CAA4C,QAAQ,QAAQ,uEAAuE,uCAAuC,aAAa,WAAW,SAAS,uBAAuB,oDAAoD,UAAU,QAAQ,sGAAsG,kCAAkC,mCAAmC,YAAY,MAAM,0EAA0E,4EAA4E,8EAA8E,4EAA4E,uDAAuD,WAAW,SAAS,wFAAwF,qBAAqB,YAAY,QAAQ,uBAAuB,UAAU,QAAQ,wGAAwG,oCAAoC,sDAAsD,cAAc,MAAM,oFAAoF,8EAA8E,gFAAgF,8EAA8E,yDAAyD,aAAa,WAAW,SAAS,6DAA6D,oBAAoB,QAAQ,mCAAmC,QAAQ,QAAQ,gCAAgC,yDAAyD,qDAAqD,uEAAuE,QAAQ,QAAQ,uEAAuE,0CAA0C,WAAW,mEAAmE,QAAQ,QAAQ,+BAA+B,iDAAiD,4CAA4C,QAAQ,QAAQ,uEAAuE,sCAAsC,gDAAgD,gBAAgB,MAAM,+FAA+F,eAAe,aAAa,WAAW,SAAS,0EAA0E,+CAA+C,qEAAqE,+CAA+C,+BAA+B,2BAA2B,gDAAgD,oDAAoD,UAAU,QAAQ,gCAAgC,6EAA6E,aAAa,8CAA8C,gCAAgC,iDAAiD,UAAU,QAAQ,gCAAgC,6EAA6E,aAAa,YAAY,MAAM,oDAAoD,UAAU,QAAQ,gCAAgC,kDAAkD,aAAa,iDAAiD,UAAU,QAAQ,gCAAgC,+FAA+F,aAAa,WAAW,2HAA2H,SAAS,uFAAuF,+CAA+C,4BAA4B,0CAA0C,sCAAsC,0CAA0C,QAAQ,QAAQ,+BAA+B,0CAA0C,0DAA0D,WAAW,2IAA2I,WAAW,oDAAoD,mBAAmB,2BAA2B,+BAA+B,kBAAkB,oBAAoB,8CAA8C,4DAA4D,iEAAiE,yBAAyB,QAAQ,QAAQ,mCAAmC,yCAAyC,4KAA4K,+BAA+B,aAAa,WAAW,SAAS,+BAA+B,gCAAgC,8BAA8B,8BAA8B,SAAS,kCAAkC,yBAAyB,uBAAuB,uBAAuB,mDAAmD,2GAA2G,4BAA4B,0BAA0B,0BAA0B,SAAS,mCAAmC,yBAAyB,uBAAuB,uBAAuB,yBAAyB,uBAAuB,uBAAuB,qDAAqD,+HAA+H,4BAA4B,0BAA0B,0BAA0B,4BAA4B,0BAA0B,0BAA0B,SAAS,qCAAqC,wDAAwD,2DAA2D,2DAA2D,2DAA2D,SAAS,qCAAqC,oCAAoC,kCAAkC,SAAS,iCAAiC,wCAAwC,wFAAwF,4EAA4E,SAAS,QAAQ,0CAA0C,gFAAgF,2CAA2C,6CAA6C,yCAAyC,6CAA6C,yCAAyC,6CAA6C,iIAAiI,SAAS,8FAA8F,2CAA2C,6CAA6C,6CAA6C,yCAAyC,6CAA6C,6CAA6C,yCAAyC,6CAA6C,6CAA6C,yCAAyC,6CAA6C,6CAA6C,+CAA+C,+LAA+L,YAAY,MAAM,+LAA+L,WAAW,SAAS,MAAM,0KAA0K,oYAAoY,6EAA6E,8BAA8B,mCAAmC,2BAA2B,yDAAyD,8EAA8E,2BAA2B,OAAO,mEAAmE,sDAAsD,kFAAkF,sCAAsC,mCAAmC,0CAA0C,kGAAkG,8BAA8B,SAAS,4FAA4F,2IAA2I,yGAAyG,yEAAyE,mFAAmF,+DAA+D,yCAAyC,OAAO,sFAAsF,kEAAkE,oTAAoT,8BAA8B,qCAAqC,2BAA2B,kOAAkO,mJAAmJ,2BAA2B,OAAO,qEAAqE,0DAA0D,yJAAyJ,oCAAoC,2CAA2C,2BAA2B,kOAAkO,6BAA6B,wEAAwE,wEAAwE,yDAAyD,oEAAoE,+DAA+D,sEAAsE,gDAAgD,mBAAmB,sBAAsB,oBAAoB,mCAAmC,iCAAiC,2CAA2C,wBAAwB,uBAAuB,mBAAmB,mEAAmE,sBAAsB,SAAS,+BAA+B,sCAAsC,wBAAwB,qBAAqB,SAAS,uCAAuC,uIAAuI,uEAAuE,8GAA8G,0DAA0D,wFAAwF,uDAAuD,kDAAkD,yCAAyC,WAAW,mCAAmC,SAAS,wCAAwC,qBAAqB,SAAS,wBAAwB,oBAAoB,SAAS,yCAAyC,mCAAmC,uCAAuC,2CAA2C,sEAAsE,yFAAyF,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,iFAAiF,sEAAsE,iOAAiO,8BAA8B,mCAAmC,2BAA2B,+MAA+M,2IAA2I,2BAA2B,OAAO,mEAAmE,sDAAsD,+IAA+I,oCAAoC,yCAAyC,2BAA2B,+MAA+M,yCAAyC,qCAAqC,+DAA+D,0EAA0E,uFAAuF,+EAA+E,2CAA2C,wBAAwB,uBAAuB,mBAAmB,oDAAoD,+BAA+B,uEAAuE,iCAAiC,6BAA6B,eAAe,kEAAkE,kBAAkB,QAAQ,uBAAuB,oBAAoB,QAAQ,gJAAgJ,yEAAyE,kDAAkD,0DAA0D,yDAAyD,uEAAuE,oDAAoD,mCAAmC,WAAW,wFAAwF,SAAS,uCAAuC,iBAAiB,QAAQ,4DAA4D,uBAAuB,mBAAmB,QAAQ,4CAA4C,4BAA4B,8CAA8C,8CAA8C,8BAA8B,wDAAwD,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,+EAA+E,kEAAkE,4SAA4S,8BAA8B,oCAAoC,2BAA2B,iHAAiH,oGAAoG,2BAA2B,OAAO,oEAAoE,wDAAwD,yGAAyG,oCAAoC,0CAA0C,2BAA2B,iHAAiH,gDAAgD,+BAA+B,2CAA2C,sHAAsH,6CAA6C,wBAAwB,mBAAmB,4CAA4C,2CAA2C,iCAAiC,6BAA6B,eAAe,yDAAyD,eAAe,QAAQ,+DAA+D,oCAAoC,kCAAkC,uBAAuB,4BAA4B,QAAQ,gEAAgE,mCAAmC,yCAAyC,0DAA0D,iDAAiD,2CAA2C,mCAAmC,aAAa,SAAS,uCAAuC,cAAc,QAAQ,uBAAuB,2BAA2B,QAAQ,yCAAyC,yBAAyB,uCAAuC,2CAA2C,2BAA2B,wDAAwD,kCAAkC,WAAW,SAAS,0DAA0D,iFAAiF,sEAAsE,+DAA+D,uNAAuN,qDAAqD,+BAA+B,+BAA+B,8BAA8B,kHAAkH,8BAA8B,mBAAmB,gBAAgB,oGAAoG,kCAAkC,kCAAkC,0GAA0G,yCAAyC,yCAAyC,6EAA6E,iHAAiH,2DAA2D,2DAA2D,WAAW,SAAS,OAAO,gFAAgF,oEAAoE,2LAA2L,8BAA8B,oCAAoC,kDAAkD,qFAAqF,sDAAsD,SAAS,2BAA2B,mEAAmE,oFAAoF,2BAA2B,OAAO,oEAAoE,wDAAwD,oDAAoD,0DAA0D,4CAA4C,sCAAsC,QAAQ,yFAAyF,oCAAoC,0CAA0C,2BAA2B,mEAAmE,4CAA4C,2CAA2C,wBAAwB,uBAAuB,mBAAmB,sDAAsD,yBAAyB,mHAAmH,6BAA6B,UAAU,MAAM,2BAA2B,mBAAmB,QAAQ,oCAAoC,wDAAwD,qEAAqE,yBAAyB,WAAW,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,iEAAiE,8BAA8B,gDAAgD,0DAA0D,2CAA2C,sCAAsC,4GAA4G,oDAAoD,gHAAgH,OAAO,QAAQ,0CAA0C,mEAAmE,sDAAsD,eAAe,aAAa,WAAW,+EAA+E,mHAAmH,OAAO,QAAQ,wCAAwC,4DAA4D,WAAW,oFAAoF,OAAO,QAAQ,4CAA4C,mDAAmD,kCAAkC,0CAA0C,uBAAuB,6DAA6D,OAAO,QAAQ,kCAAkC,4CAA4C,0CAA0C,0CAA0C,oCAAoC,0BAA0B,WAAW,SAAS,OAAO,gFAAgF,oEAAoE,0DAA0D,gEAAgE,4CAA4C,sCAAsC,QAAQ,+CAA+C,yBAAyB,wCAAwC,8CAA8C,OAAO,QAAQ,oCAAoC,2CAA2C,WAAW,UAAU,MAAM,0CAA0C,SAAS,oBAAoB,OAAO,uLAAuL,oCAAoC,oCAAoC,2BAA2B,8CAA8C,+EAA+E,2CAA2C,iGAAiG,qCAAqC,eAAe,wCAAwC,wDAAwD,0CAA0C,qCAAqC,iDAAiD,UAAU,MAAM,uCAAuC,SAAS,kCAAkC,qCAAqC,gDAAgD,kCAAkC,8IAA8I,OAAO,QAAQ,gCAAgC,2BAA2B,OAAO,QAAQ,sCAAsC,gDAAgD,+CAA+C,+CAA+C,8CAA8C,+CAA+C,+BAA+B,mEAAmE,cAAc,MAAM,qCAAqC,aAAa,WAAW,SAAS,0DAA0D,+BAA+B,yQAAyQ,oDAAoD,wDAAwD,gDAAgD,wDAAwD,WAAW,SAAS,4GAA4G,OAAO,0EAA0E,wDAAwD,8QAA8Q,8BAA8B,uCAAuC,2BAA2B,yQAAyQ,qKAAqK,2BAA2B,OAAO,uEAAuE,8DAA8D,6KAA6K,oCAAoC,6CAA6C,2BAA2B,yQAAyQ,yBAAyB,4DAA4D,mEAAmE,2BAA2B,2DAA2D,yDAAyD,gEAAgE,+DAA+D,0EAA0E,2CAA2C,wBAAwB,uBAAuB,mBAAmB,iDAAiD,0BAA0B,kCAAkC,yBAAyB,oDAAoD,oCAAoC,mDAAmD,qDAAqD,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,kCAAkC,mBAAmB,mCAAmC,mCAAmC,6BAA6B,gHAAgH,sEAAsE,qBAAqB,QAAQ,8BAA8B,uCAAuC,4HAA4H,yBAAyB,qBAAqB,QAAQ,yCAAyC,uDAAuD,+CAA+C,6CAA6C,kEAAkE,iDAAiD,yCAAyC,0DAA0D,yFAAyF,yDAAyD,sDAAsD,+FAA+F,aAAa,sGAAsG,WAAW,oDAAoD,oBAAoB,QAAQ,yBAAyB,oBAAoB,QAAQ,gHAAgH,6CAA6C,iDAAiD,6CAA6C,4DAA4D,oCAAoC,mEAAmE,aAAa,WAAW,uIAAuI,oFAAoF,SAAS,qCAAqC,kDAAkD,iCAAiC,mCAAmC,6BAA6B,mEAAmE,8CAA8C,uFAAuF,kNAAkN,qBAAqB,QAAQ,0EAA0E,4DAA4D,kDAAkD,kDAAkD,WAAW,sFAAsF,6FAA6F,qBAAqB,QAAQ,uCAAuC,mDAAmD,6CAA6C,2CAA2C,8DAA8D,uCAAuC,uCAAuC,wDAAwD,4DAA4D,6DAA6D,iDAAiD,iCAAiC,kDAAkD,WAAW,oDAAoD,oBAAoB,QAAQ,yCAAyC,qCAAqC,iCAAiC,mEAAmE,cAAc,MAAM,sEAAsE,aAAa,4BAA4B,WAAW,0JAA0J,oFAAoF,SAAS,OAAO,mFAAmF,0EAA0E,gNAAgN,6HAA6H,mCAAmC,2BAA2B,gOAAgO,OAAO,2EAA2E,sDAAsD,oJAAoJ,mIAAmI,yCAAyC,2BAA2B,gOAAgO,OAAO,uFAAuF,kEAAkE,qPAAqP,8BAA8B,qCAAqC,2BAA2B,yHAAyH,yGAAyG,2BAA2B,OAAO,qEAAqE,0DAA0D,+GAA+G,oCAAoC,2CAA2C,2BAA2B,yHAAyH,6BAA6B,sEAAsE,+DAA+D,0EAA0E,2CAA2C,wBAAwB,uBAAuB,mBAAmB,4CAA4C,iCAAiC,6BAA6B,wDAAwD,8BAA8B,2BAA2B,4BAA4B,eAAe,gBAAgB,gEAAgE,qEAAqE,gDAAgD,wDAAwD,qDAAqD,oEAAoE,sDAAsD,iCAAiC,SAAS,uCAAuC,eAAe,QAAQ,sCAAsC,SAAS,0DAA0D,iFAAiF,8EAA8E,sEAAsE,OAAO,iFAAiF,sEAAsE,0CAA0C,s1DAAs1D,EAAE,8EAA8E,6DAA6D,oDAAoD,8BAA8B,qCAAqC,2CAA2C,yBAAyB,2BAA2B,8BAA8B,qCAAqC,OAAO,qEAAqE,0DAA0D,uDAAuD,0GAA0G,gDAAgD,wCAAwC,OAAO,8EAA8E,gEAAgE,6DAA6D,8FAA8F,4rCAA4rC,0DAA0D,8BAA8B,yBAAyB,iBAAiB,2CAA2C,4CAA4C,qCAAqC,2BAA2B,wBAAwB,6BAA6B,mCAAmC,0BAA0B,gCAAgC,8CAA8C,mCAAmC,8BAA8B,4BAA4B,yBAAyB,8BAA8B,6CAA6C,oCAAoC,iCAAiC,gCAAgC,iCAAiC,iCAAiC,6BAA6B,2BAA2B,iCAAiC,oCAAoC,+BAA+B,kCAAkC,sCAAsC,uCAAuC,8BAA8B,gCAAgC,gCAAgC,qCAAqC,OAAO,2EAA2E,sEAAsE,mEAAmE,iEAAiE,qDAAqD,yBAAyB,iBAAiB,wCAAwC,wCAAwC,wCAAwC,8BAA8B,wCAAwC,wDAAwD,kCAAkC,kDAAkD,8CAA8C,4CAA4C,wDAAwD,sCAAsC,wCAAwC,0CAA0C,kDAAkD,sDAAsD,wDAAwD,sDAAsD,gDAAgD,gDAAgD,wCAAwC,oCAAoC,oDAAoD,sDAAsD,0CAA0C,0DAA0D,sDAAsD,wDAAwD,wCAAwC,8CAA8C,8CAA8C,oBAAoB,QAAQ,8FAA8F,qCAAqC,0DAA0D,0CAA0C,yBAAyB,iBAAiB,2CAA2C,iCAAiC,iDAAiD,oCAAoC,qCAAqC,OAAO,uFAAuF,sEAAsE,mEAAmE,iEAAiE,iEAAiE,yBAAyB,iBAAiB,gDAAgD,0CAA0C,0DAA0D,oBAAoB,QAAQ,iIAAiI,upCAAupC,uDAAuD,8BAA8B,wCAAwC,4CAA4C,sDAAsD,0BAA0B,wBAAwB,6BAA6B,mCAAmC,0BAA0B,gCAAgC,8CAA8C,mCAAmC,8BAA8B,4BAA4B,yBAAyB,8BAA8B,6CAA6C,oCAAoC,iCAAiC,gCAAgC,gCAAgC,6BAA6B,2BAA2B,uCAAuC,4BAA4B,kCAAkC,+BAA+B,kCAAkC,sCAAsC,uCAAuC,8BAA8B,gCAAgC,gCAAgC,qCAAqC,OAAO,wEAAwE,gEAAgE,6DAA6D,8DAA8D,qDAAqD,wCAAwC,4CAA4C,wCAAwC,8BAA8B,wCAAwC,wDAAwD,kCAAkC,kDAAkD,8CAA8C,4CAA4C,wDAAwD,sCAAsC,wCAAwC,0CAA0C,kDAAkD,sDAAsD,wDAAwD,sDAAsD,8CAA8C,wCAAwC,oCAAoC,oCAAoC,8CAA8C,oDAAoD,0CAA0C,0DAA0D,sDAAsD,wDAAwD,wCAAwC,8CAA8C,8CAA8C,oBAAoB,QAAQ,0FAA0F,yDAAyD,sDAAsD,uCAAuC,yBAAyB,aAAa,uCAAuC,gCAAgC,qCAAqC,OAAO,gFAAgF,8DAA8D,2DAA2D,6DAA6D,8DAA8D,8CAA8C,oBAAoB,QAAQ,wIAAwI,oeAAoe,wDAAwD,8BAA8B,yCAAyC,4BAA4B,yBAAyB,8BAA8B,6CAA6C,oCAAoC,iCAAiC,gCAAgC,+BAA+B,kCAAkC,yBAAyB,0BAA0B,8BAA8B,gCAAgC,gCAAgC,qCAAqC,OAAO,yEAAyE,kEAAkE,+DAA+D,+DAA+D,qDAAqD,sCAAsC,wCAAwC,0CAA0C,kDAAkD,sDAAsD,wDAAwD,sDAAsD,0CAA0C,0DAA0D,wCAAwC,8CAA8C,8CAA8C,oBAAoB,QAAQ,iIAAiI,+zBAA+zB,yDAAyD,8BAA8B,0CAA0C,4CAA4C,kCAAkC,6BAA6B,mCAAmC,0BAA0B,gCAAgC,8CAA8C,mCAAmC,8BAA8B,gCAAgC,6BAA6B,2BAA2B,uCAAuC,4BAA4B,kCAAkC,+BAA+B,kCAAkC,sCAAsC,uCAAuC,8BAA8B,gCAAgC,gCAAgC,qCAAqC,OAAO,0EAA0E,oEAAoE,iEAAiE,gEAAgE,qDAAqD,wCAAwC,8BAA8B,wCAAwC,wDAAwD,kCAAkC,kDAAkD,8CAA8C,4CAA4C,wDAAwD,8CAA8C,wCAAwC,oCAAoC,oCAAoC,8CAA8C,oDAAoD,0CAA0C,0DAA0D,sDAAsD,wDAAwD,wCAAwC,8CAA8C,8CAA8C,oBAAoB,QAAQ,uFAAuF,sKAAsK,wDAAwD,uCAAuC,yCAAyC,uBAAuB,wBAAwB,uBAAuB,qCAAqC,OAAO,kFAAkF,kEAAkE,+DAA+D,+DAA+D,8DAA8D,kCAAkC,sCAAsC,oCAAoC,oBAAoB,QAAQ,yCAAyC,6sBAA6sB,EAAE,6EAA6E,wCAAwC,sCAAsC,+CAA+C,8DAA8D,mCAAmC,SAAS,gCAAgC,+CAA+C,gEAAgE,mCAAmC,SAAS,mCAAmC,mCAAmC,SAAS,6BAA6B,0BAA0B,SAAS,QAAQ,wHAAwH,yBAAyB,8BAA8B,0BAA0B,yBAAyB,kCAAkC,iCAAiC,2BAA2B,mCAAmC,6BAA6B,2CAA2C,wBAAwB,sCAAsC,gDAAgD,4DAA4D,aAAa,WAAW,2BAA2B,UAAU,yCAAyC,yBAAyB,iDAAiD,6DAA6D,WAAW,6CAA6C,8BAA8B,+CAA+C,6BAA6B,aAAa,WAAW,UAAU,2CAA2C,8CAA8C,iCAAiC,WAAW,UAAU,4CAA4C,8BAA8B,sCAAsC,WAAW,qBAAqB,UAAU,sDAAsD,kCAAkC,oBAAoB,UAAU,OAAO,uDAAuD,iFAAiF,sCAAsC,mFAAmF,OAAO,4CAA4C,6DAA6D,4CAA4C,+DAA+D,+CAA+C,2BAA2B,wCAAwC,uCAAuC,2CAA2C,qCAAqC,6CAA6C,2CAA2C,aAAa,MAAM,0BAA0B,WAAW,yFAAyF,kCAAkC,0GAA0G,EAAE,mBAAmB,WAAW,yEAAyE,gBAAgB,2DAA2D,0HAA0H,mDAAmD,oDAAoD,6CAA6C,qDAAqD,uDAAuD,iBAAiB,2BAA2B,yEAAyE,uCAAuC,wHAAwH,mCAAmC,iBAAiB,QAAQ,qDAAqD,mBAAmB,kDAAkD,4DAA4D,iBAAiB,EAAE,oBAAoB,MAAM,2CAA2C,mBAAmB,wBAAwB,+EAA+E,oEAAoE,wBAAwB,4EAA4E,wBAAwB,6EAA6E,wBAAwB,eAAe,2IAA2I,iDAAiD,6CAA6C,eAAe,MAAM,cAAc,iBAAiB,2IAA2I,gDAAgD,6CAA6C,6CAA6C,eAAe,MAAM,aAAa,YAAY,MAAM,sFAAsF,kCAAkC,0GAA0G,EAAE,+CAA+C,6CAA6C,kEAAkE,2CAA2C,yCAAyC,6CAA6C,oCAAoC,0CAA0C,wDAAwD,QAAQ,QAAQ,gDAAgD,mEAAmE,iBAAiB,6CAA6C,gBAAgB,+BAA+B,8NAA8N,wDAAwD,QAAQ,QAAQ,gDAAgD,mEAAmE,iBAAiB,6CAA6C,gBAAgB,MAAM,wDAAwD,QAAQ,QAAQ,gDAAgD,kEAAkE,iBAAiB,6CAA6C,6CAA6C,eAAe,aAAa,UAAU,sEAAsE,6CAA6C,sDAAsD,QAAQ,QAAQ,8CAA8C,sEAAsE,eAAe,aAAa,UAAU,mEAAmE,6CAA6C,oCAAoC,sDAAsD,QAAQ,QAAQ,8CAA8C,gEAAgE,eAAe,2CAA2C,2CAA2C,aAAa,UAAU,4FAA4F,mGAAmG,mIAAmI,sDAAsD,+EAA+E,aAAa,iCAAiC,WAAW,yCAAyC,yBAAyB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,8CAA8C,oCAAoC,oBAAoB,SAAS,iDAAiD,uCAAuC,oBAAoB,SAAS,0CAA0C,gCAAgC,oBAAoB,SAAS,+CAA+C,qCAAqC,oBAAoB,SAAS,QAAQ,EAAE,4LAA4L,mFAAmF,4DAA4D,OAAO,yDAAyD,6DAA6D,2BAA2B,0BAA0B,gDAAgD,+BAA+B,sDAAsD,oCAAoC,gDAAgD,qCAAqC,wDAAwD,2DAA2D,6BAA6B,qKAAqK,0BAA0B,mCAAmC,kGAAkG,iDAAiD,yCAAyC,gDAAgD,eAAe,aAAa,wBAAwB,WAAW,uCAAuC,2BAA2B,8CAA8C,QAAQ,QAAQ,+BAA+B,aAAa,YAAY,MAAM,wHAAwH,2DAA2D,yCAAyC,2EAA2E,iCAAiC,WAAW,QAAQ,kCAAkC,cAAc,mCAAmC,0BAA0B,QAAQ,iGAAiG,uDAAuD,qDAAqD,uDAAuD,mBAAmB,iBAAiB,gBAAgB,MAAM,qDAAqD,qDAAqD,iDAAiD,eAAe,iDAAiD,iDAAiD,eAAe,+CAA+C,uCAAuC,8CAA8C,aAAa,wBAAwB,WAAW,yBAAyB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,EAAE,0MAA0M,mFAAmF,4DAA4D,OAAO,mDAAmD,6DAA6D,2BAA2B,0CAA0C,sDAAsD,gDAAgD,iDAAiD,kDAAkD,oCAAoC,gDAAgD,4CAA4C,cAAc,wCAAwC,kDAAkD,kDAAkD,8CAA8C,aAAa,8FAA8F,4FAA4F,mGAAmG,6GAA6G,2FAA2F,iDAAiD,8CAA8C,aAAa,6CAA6C,0CAA0C,aAAa,kDAAkD,gDAAgD,aAAa,8CAA8C,+CAA+C,aAAa,uCAAuC,qDAAqD,WAAW,wBAAwB,2BAA2B,SAAS,QAAQ,EAAE,iGAAiG,mFAAmF,OAAO,6CAA6C,8FAA8F,4CAA4C,+DAA+D,+CAA+C,2BAA2B,wCAAwC,uCAAuC,2CAA2C,qCAAqC,6CAA6C,2CAA2C,aAAa,MAAM,0BAA0B,WAAW,wFAAwF,uDAAuD,mCAAmC,yCAAyC,yCAAyC,WAAW,UAAU,4EAA4E,kDAAkD,WAAW,UAAU,yEAAyE,4CAA4C,yCAAyC,yCAAyC,WAAW,UAAU,iDAAiD,uFAAuF,WAAW,yCAAyC,0BAA0B,uBAAuB,SAAS,6CAA6C,mCAAmC,oBAAoB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,EAAE,uGAAuG,mFAAmF,OAAO,mDAAmD,+FAA+F,0CAA0C,uDAAuD,kDAAkD,oCAAoC,yBAAyB,qCAAqC,wDAAwD,0CAA0C,wBAAwB,mCAAmC,2CAA2C,gDAAgD,eAAe,aAAa,uBAAuB,WAAW,2BAA2B,iBAAiB,QAAQ,6BAA6B,WAAW,yBAAyB,SAAS,6CAA6C,mCAAmC,oBAAoB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,EAAE,mGAAmG,mFAAmF,OAAO,+CAA+C,8FAA8F,sCAAsC,uDAAuD,kDAAkD,oCAAoC,gDAAgD,kCAAkC,wMAAwM,6DAA6D,qCAAqC,yCAAyC,gCAAgC,aAAa,WAAW,wBAAwB,yBAAyB,SAAS,6CAA6C,mCAAmC,oBAAoB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,EAAE,y+BAAy+B,4BAA4B,sCAAsC,OAAO,uCAAuC,2JAA2J,sEAAsE,oBAAoB,SAAS,oJAAoJ,2CAA2C,kDAAkD,SAAS,iGAAiG,uDAAuD,0BAA0B,2BAA2B,gBAAgB,QAAQ,0DAA0D,WAAW,wBAAwB,SAAS,yGAAyG,uDAAuD,0BAA0B,2BAA2B,gBAAgB,QAAQ,4DAA4D,WAAW,wBAAwB,SAAS,sEAAsE,0CAA0C,6CAA6C,SAAS,8FAA8F,6EAA6E,oIAAoI,wCAAwC,WAAW,mCAAmC,yBAAyB,+CAA+C,uBAAuB,0BAA0B,uBAAuB,gBAAgB,QAAQ,qDAAqD,4CAA4C,4BAA4B,yBAAyB,WAAW,uCAAuC,wBAAwB,KAAK,yBAAyB,oCAAoC,wCAAwC,kCAAkC,0BAA0B,SAAS,gJAAgJ,6CAA6C,4CAA4C,+BAA+B,kEAAkE,uCAAuC,YAAY,MAAM,uDAAuD,WAAW,2IAA2I,iCAAiC,wDAAwD,8KAA8K,mCAAmC,0BAA0B,cAAc,4BAA4B,2BAA2B,cAAc,MAAM,uBAAuB,kBAAkB,kCAAkC,WAAW,mBAAmB,sDAAsD,kCAAkC,WAAW,6IAA6I,8CAA8C,yDAAyD,8JAA8J,mGAAmG,mBAAmB,SAAS,yRAAyR,6BAA6B,2BAA2B,2BAA2B,qEAAqE,6BAA6B,wCAAwC,sCAAsC,2CAA2C,+BAA+B,SAAS,uCAAuC,2CAA2C,oCAAoC,SAAS,6DAA6D,yGAAyG,4BAA4B,yBAAyB,2BAA2B,kCAAkC,gCAAgC,0BAA0B,6FAA6F,eAAe,QAAQ,6BAA6B,mDAAmD,oCAAoC,WAAW,kMAAkM,uCAAuC,mCAAmC,6CAA6C,6CAA6C,6CAA6C,4BAA4B,qBAAqB,gCAAgC,WAAW,4BAA4B,qBAAqB,gCAAgC,WAAW,4BAA4B,kCAAkC,WAAW,gEAAgE,0DAA0D,mEAAmE,0HAA0H,eAAe,QAAQ,oDAAoD,wDAAwD,iEAAiE,kDAAkD,8BAA8B,kGAAkG,6GAA6G,aAAa,uEAAuE,WAAW,gJAAgJ,gGAAgG,4BAA4B,mGAAmG,8BAA8B,aAAa,yBAAyB,eAAe,QAAQ,4HAA4H,uEAAuE,aAAa,WAAW,kBAAkB,gGAAgG,SAAS,6BAA6B,qDAAqD,SAAS,oCAAoC,8DAA8D,sBAAsB,SAAS,8BAA8B,sBAAsB,qBAAqB,mGAAmG,UAAU,4DAA4D,8BAA8B,sBAAsB,SAAS,sCAAsC,4DAA4D,sBAAsB,SAAS,QAAQ,EAAE,wGAAwG,2BAA2B,mCAAmC,0BAA0B,wBAAwB,oCAAoC,kCAAkC,4CAA4C,gDAAgD,8CAA8C,wCAAwC,OAAO,gEAAgE,sDAAsD,mDAAmD,wEAAwE,oDAAoD,gCAAgC,yDAAyD,+DAA+D,kGAAkG,uDAAuD,4CAA4C,6BAA6B,2BAA2B,YAAY,MAAM,+BAA+B,WAAW,SAAS,yDAAyD,uCAAuC,iCAAiC,YAAY,MAAM,4CAA4C,WAAW,SAAS,sDAAsD,yDAAyD,yDAAyD,qCAAqC,+CAA+C,6CAA6C,+BAA+B,6BAA6B,wGAAwG,0CAA0C,SAAS,iCAAiC,QAAQ,yDAAyD,kDAAkD,4BAA4B,0BAA0B,sCAAsC,oCAAoC,8CAA8C,wCAAwC,4CAA4C,0CAA0C,oBAAoB,QAAQ,qDAAqD,uDAAuD,0BAA0B,wBAAwB,oCAAoC,kCAAkC,4CAA4C,sCAAsC,0CAA0C,wCAAwC,oBAAoB,QAAQ,2DAA2D,oDAAoD,0BAA0B,wBAAwB,oCAAoC,kCAAkC,4CAA4C,sCAAsC,0CAA0C,wCAAwC,oBAAoB,QAAQ,gFAAgF,gGAAgG,+BAA+B,OAAO,mEAAmE,8CAA8C,2CAA2C,61BAA61B,2CAA2C,2PAA2P,kBAAkB,gBAAgB,6CAA6C,uCAAuC,SAAS,gBAAgB,gEAAgE,yEAAyE,WAAW,iFAAiF,oJAAoJ,uFAAuF,gFAAgF,oBAAoB,mCAAmC,WAAW,iCAAiC,2BAA2B,0BAA0B,iDAAiD,WAAW,UAAU,OAAO,sCAAsC,6BAA6B,6BAA6B,6BAA6B,uEAAuE,2BAA2B,uCAAuC,mCAAmC,oCAAoC,kDAAkD,oCAAoC,OAAO,oEAAoE,8DAA8D,2DAA2D,4EAA4E,oDAAoD,iCAAiC,4BAA4B,oDAAoD,qCAAqC,gCAAgC,4BAA4B,oHAAoH,UAAU,gDAAgD,2BAA2B,mBAAmB,SAAS,4BAA4B,uDAAuD,8CAA8C,UAAU,MAAM,0GAA0G,iBAAiB,SAAS,oCAAoC,0CAA0C,gDAAgD,8CAA8C,UAAU,MAAM,qHAAqH,iBAAiB,SAAS,iFAAiF,+GAA+G,8DAA8D,8DAA8D,8DAA8D,iFAAiF,oCAAoC,oCAAoC,+EAA+E,6EAA6E,6EAA6E,UAAU,6CAA6C,oEAAoE,kEAAkE,kEAAkE,SAAS,uGAAuG,qBAAqB,QAAQ,6DAA6D,kDAAkD,yBAAyB,mDAAmD,OAAO,QAAQ,yCAAyC,4CAA4C,SAAS,oCAAoC,wCAAwC,oCAAoC,oBAAoB,QAAQ,uDAAuD,uDAAuD,yBAAyB,iDAAiD,OAAO,QAAQ,uCAAuC,4CAA4C,SAAS,kCAAkC,sCAAsC,kCAAkC,oBAAoB,QAAQ,+DAA+D,oDAAoD,yBAAyB,iDAAiD,OAAO,QAAQ,uCAAuC,6DAA6D,SAAS,kCAAkC,sCAAsC,kCAAkC,oBAAoB,QAAQ,yNAAyN,mCAAmC,iCAAiC,qBAAqB,sBAAsB,yGAAyG,OAAO,kDAAkD,sBAAsB,uBAAuB,OAAO,0CAA0C,qCAAqC,OAAO,0CAA0C,yBAAyB,OAAO,iDAAiD,2GAA2G,OAAO,8CAA8C,sBAAsB,2BAA2B,OAAO,sCAAsC,sBAAsB,+BAA+B,OAAO,sCAAsC,yCAAyC,OAAO,sCAAsC,6BAA6B,OAAO,iDAAiD,wHAAwH,OAAO,mDAAmD,2BAA2B,uCAAuC,sCAAsC,oCAAoC,oCAAoC,oCAAoC,OAAO,oEAAoE,8DAA8D,2DAA2D,4EAA4E,oDAAoD,mEAAmE,2HAA2H,qBAAqB,QAAQ,6DAA6D,kDAAkD,kCAAkC,gCAAgC,gCAAgC,gCAAgC,oBAAoB,QAAQ,uDAAuD,uDAAuD,oCAAoC,kCAAkC,kCAAkC,kCAAkC,oBAAoB,QAAQ,+DAA+D,oDAAoD,qCAAqC,mCAAmC,mCAAmC,mCAAmC,oBAAoB,QAAQ,oDAAoD,2BAA2B,wCAAwC,sCAAsC,oCAAoC,oCAAoC,oCAAoC,OAAO,qEAAqE,gEAAgE,6DAA6D,6EAA6E,oDAAoD,mEAAmE,4KAA4K,qBAAqB,QAAQ,8DAA8D,kDAAkD,kCAAkC,gCAAgC,gCAAgC,gCAAgC,oBAAoB,QAAQ,wDAAwD,uDAAuD,oCAAoC,kCAAkC,kCAAkC,kCAAkC,oBAAoB,QAAQ,gEAAgE,oDAAoD,qCAAqC,mCAAmC,mCAAmC,mCAAmC,oBAAoB,QAAQ,oCAAoC,2BAA2B,gCAAgC,sCAAsC,oCAAoC,OAAO,6DAA6D,gDAAgD,6CAA6C,qEAAqE,oDAAoD,wBAAwB,gCAAgC,UAAU,MAAM,+CAA+C,iDAAiD,SAAS,qBAAqB,QAAQ,4IAA4I,kDAAkD,QAAQ,6DAA6D,qDAAqD,mCAAmC,QAAQ,sDAAsD,kDAAkD,kCAAkC,gCAAgC,oBAAoB,QAAQ,gDAAgD,uDAAuD,oCAAoC,kCAAkC,oBAAoB,QAAQ,wDAAwD,oDAAoD,qCAAqC,mCAAmC,oBAAoB,QAAQ,qCAAqC,2BAA2B,iCAAiC,sCAAsC,oCAAoC,OAAO,8DAA8D,kDAAkD,+CAA+C,sEAAsE,oDAAoD,wBAAwB,gCAAgC,UAAU,MAAM,+CAA+C,iDAAiD,SAAS,qBAAqB,QAAQ,6IAA6I,kDAAkD,QAAQ,uDAAuD,kDAAkD,kCAAkC,gCAAgC,oBAAoB,QAAQ,iDAAiD,uDAAuD,oCAAoC,kCAAkC,oBAAoB,QAAQ,yDAAyD,oDAAoD,qCAAqC,mCAAmC,oBAAoB,QAAQ,mDAAmD,2BAA2B,2CAA2C,sCAAsC,oCAAoC,oCAAoC,OAAO,wEAAwE,sEAAsE,mEAAmE,gFAAgF,oDAAoD,qDAAqD,uHAAuH,qBAAqB,QAAQ,iEAAiE,kDAAkD,kCAAkC,gCAAgC,gCAAgC,oBAAoB,QAAQ,2DAA2D,uDAAuD,oCAAoC,kCAAkC,kCAAkC,oBAAoB,QAAQ,mEAAmE,oDAAoD,qCAAqC,mCAAmC,mCAAmC,oBAAoB,QAAQ,oDAAoD,2BAA2B,4CAA4C,sCAAsC,oCAAoC,oCAAoC,OAAO,yEAAyE,wEAAwE,qEAAqE,iFAAiF,oDAAoD,qDAAqD,sKAAsK,qBAAqB,QAAQ,kEAAkE,kDAAkD,kCAAkC,gCAAgC,gCAAgC,oBAAoB,QAAQ,4DAA4D,uDAAuD,oCAAoC,kCAAkC,kCAAkC,oBAAoB,QAAQ,oEAAoE,oDAAoD,qCAAqC,mCAAmC,mCAAmC,oBAAoB,QAAQ,6DAA6D,2BAA2B,kCAAkC,mCAAmC,OAAO,+DAA+D,oDAAoD,iDAAiD,uEAAuE,oDAAoD,iCAAiC,wCAAwC,uCAAuC,gCAAgC,oEAAoE,kCAAkC,yFAAyF,yFAAyF,mIAAmI,qBAAqB,QAAQ,wDAAwD,kDAAkD,yBAAyB,mDAAmD,OAAO,QAAQ,yCAAyC,4CAA4C,SAAS,oBAAoB,QAAQ,kDAAkD,uDAAuD,yBAAyB,iDAAiD,OAAO,QAAQ,uCAAuC,4CAA4C,SAAS,oBAAoB,QAAQ,0DAA0D,oDAAoD,yBAAyB,iDAAiD,OAAO,QAAQ,uCAAuC,6DAA6D,SAAS,oBAAoB,QAAQ,sCAAsC,sXAAsX,EAAE,mWAAmW,2BAA2B,gCAAgC,yBAAyB,8BAA8B,uCAAuC,8EAA8E,gEAAgE,oCAAoC,SAAS,iCAAiC,iIAAiI,2EAA2E,kDAAkD,sEAAsE,WAAW,SAAS,wUAAwU,uCAAuC,kDAAkD,kBAAkB,2FAA2F,2CAA2C,+CAA+C,yCAAyC,oDAAoD,uEAAuE,2CAA2C,aAAa,iBAAiB,WAAW,sBAAsB,6DAA6D,8OAA8O,4CAA4C,uCAAuC,SAAS,mFAAmF,kCAAkC,iCAAiC,+BAA+B,SAAS,uJAAuJ,iKAAiK,qCAAqC,WAAW,+GAA+G,mDAAmD,OAAO,QAAQ,iDAAiD,+BAA+B,WAAW,sCAAsC,yBAAyB,SAAS,kDAAkD,wDAAwD,0BAA0B,2BAA2B,gBAAgB,QAAQ,0DAA0D,WAAW,iCAAiC,uCAAuC,WAAW,wBAAwB,SAAS,4CAA4C,sCAAsC,gCAAgC,iDAAiD,mBAAmB,QAAQ,oCAAoC,0OAA0O,oDAAoD,6BAA6B,gBAAgB,QAAQ,mCAAmC,4DAA4D,kFAAkF,yBAAyB,aAAa,WAAW,6GAA6G,uCAAuC,WAAW,wBAAwB,SAAS,oCAAoC,oDAAoD,2BAA2B,qDAAqD,OAAO,QAAQ,2CAA2C,8CAA8C,WAAW,4CAA4C,sBAAsB,SAAS,8BAA8B,yDAAyD,0CAA0C,yBAAyB,mDAAmD,OAAO,QAAQ,yCAAyC,6CAA6C,WAAW,sBAAsB,SAAS,sCAAsC,sDAAsD,0CAA0C,yBAAyB,mDAAmD,OAAO,QAAQ,yCAAyC,2EAA2E,WAAW,sBAAsB,SAAS,QAAQ,EAAE,iLAAiL,+BAA+B,2BAA2B,0CAA0C,uBAAuB,uCAAuC,SAAS,OAAO,6EAA6E,sEAAsE,sDAAsD,8CAA8C,OAAO,QAAQ,wDAAwD,WAAW,SAAS,oCAAoC,yCAAyC,iEAAiE,oCAAoC,sFAAsF,kCAAkC,wCAAwC,SAAS,4DAA4D,gKAAgK,oCAAoC,0CAA0C,SAAS,yEAAyE,oMAAoM,oCAAoC,0CAA0C,SAAS,2DAA2D,iEAAiE,8CAA8C,kCAAkC,0DAA0D,SAAS,gFAAgF,uCAAuC,qCAAqC,gGAAgG,SAAS,mFAAmF,0FAA0F,SAAS,wGAAwG,uCAAuC,qCAAqC,+GAA+G,SAAS,2GAA2G,kHAAkH,yCAAyC,6GAA6G,6DAA6D,wDAAwD,aAAa,WAAW,oCAAoC,8CAA8C,4CAA4C,SAAS,oCAAoC,wDAAwD,wDAAwD,sBAAsB,SAAS,8BAA8B,6DAA6D,0DAA0D,sBAAsB,SAAS,sCAAsC,0DAA0D,2DAA2D,sBAAsB,SAAS,QAAQ,EAAE,6XAA6X,kCAAkC,yCAAyC,4BAA4B,wBAAwB,OAAO,yEAAyE,2EAA2E,4BAA4B,kDAAkD,OAAO,QAAQ,mEAAmE,WAAW,0BAA0B,SAAS,gIAAgI,kBAAkB,4GAA4G,SAAS,oCAAoC,mDAAmD,0BAA0B,oDAAoD,OAAO,QAAQ,yCAAyC,4CAA4C,WAAW,sBAAsB,SAAS,8BAA8B,wDAAwD,gCAAgC,wBAAwB,kDAAkD,OAAO,QAAQ,uCAAuC,2CAA2C,WAAW,sBAAsB,SAAS,sCAAsC,qDAAqD,gCAAgC,wBAAwB,kDAAkD,OAAO,QAAQ,uCAAuC,yDAAyD,WAAW,sBAAsB,SAAS,QAAQ,EAAE,uJAAuJ,8BAA8B,4BAA4B,wCAAwC,+DAA+D,uCAAuC,OAAO,6EAA6E,oFAAoF,uDAAuD,0CAA0C,0CAA0C,sBAAsB,SAAS,oCAAoC,kEAAkE,kDAAkD,+CAA+C,oGAAoG,kFAAkF,uEAAuE,uEAAuE,gFAAgF,qFAAqF,sBAAsB,SAAS,QAAQ,EAAE,uIAAuI,gDAAgD,sCAAsC,oCAAoC,iDAAiD,0BAA0B,oDAAoD,OAAO,oFAAoF,wGAAwG,oDAAoD,sDAAsD,sBAAsB,SAAS,QAAQ,EAAE,gGAAgG,6BAA6B,sBAAsB,sBAAsB,+CAA+C,wBAAwB,kCAAkC,OAAO,6CAA6C,mCAAmC,8CAA8C,kCAAkC,oCAAoC,8CAA8C,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,8BAA8B,0BAA0B,yDAAyD,6DAA6D,wGAAwG,6DAA6D,oCAAoC,wBAAwB,SAAS,QAAQ,EAAE,4FAA4F,2EAA2E,OAAO,0FAA0F,yGAAyG,mCAAmC,oDAAoD,8DAA8D,+CAA+C,uFAAuF,6BAA6B,iCAAiC,2BAA2B,0CAA0C,WAAW,SAAS,QAAQ,EAAE,mJAAmJ,6CAA6C,gCAAgC,iDAAiD,0BAA0B,qCAAqC,+CAA+C,0BAA0B,4NAA4N,WAAW,kCAAkC,6NAA6N,WAAW,QAAQ,EAAE,kEAAkE,iEAAiE,gEAAgE,uDAAuD,4FAA4F,OAAO,8EAA8E,4FAA4F,oDAAoD,0CAA0C,kCAAkC,wCAAwC,kCAAkC,8CAA8C,8CAA8C,sBAAsB,SAAS,QAAQ,EAAE,4HAA4H,6CAA6C,iCAAiC,+CAA+C,0BAA0B,gOAAgO,WAAW,kCAAkC,qOAAqO,WAAW,QAAQ,EAAE,kEAAkE,uDAAuD,kIAAkI,OAAO,+EAA+E,8FAA8F,oDAAoD,0CAA0C,kCAAkC,8CAA8C,sBAAsB,SAAS,QAAQ,EAAE,oGAAoG,qFAAqF,OAAO,iGAAiG,mDAAmD,EAAE,kKAAkK,6CAA6C,uCAAuC,iDAAiD,0BAA0B,qCAAqC,mDAAmD,OAAO,qFAAqF,0GAA0G,oDAAoD,8CAA8C,8CAA8C,sBAAsB,SAAS,QAAQ,EAAE,2GAA2G,6CAA6C,mCAAmC,oCAAoC,OAAO,iFAAiF,sEAAsE,EAAE,yIAAyI,6CAA6C,oCAAoC,qCAAqC,0BAA0B,0DAA0D,2DAA2D,0LAA0L,4JAA4J,oGAAoG,oDAAoD,oCAAoC,oCAAoC,sBAAsB,SAAS,oCAAoC,+DAA+D,yCAAyC,yCAAyC,sBAAsB,SAAS,QAAQ,EAAE,sQAAsQ,uEAAuE,OAAO,gGAAgG,mQAAmQ,EAAE,0PAA0P,wDAAwD,OAAO,iGAAiG,icAAic,EAAE,m0BAAm0B,qDAAqD,4BAA4B,0HAA0H,uCAAuC,kCAAkC,OAAO,6CAA6C,kCAAkC,kIAAkI,8BAA8B,mBAAmB,wBAAwB,4BAA4B,gLAAgL,iDAAiD,iDAAiD,GAAG,6CAA6C,uDAAuD,uEAAuE,2CAA2C,2DAA2D,qBAAqB,kDAAkD,wCAAwC,mCAAmC,mCAAmC,8FAA8F,qBAAqB,mBAAmB,2GAA2G,kCAAkC,iBAAiB,8FAA8F,oCAAoC,sEAAsE,uCAAuC,4BAA4B,sEAAsE,mBAAmB,yFAAyF,GAAG,6CAA6C,iFAAiF,yDAAyD,qBAAqB,kDAAkD,wCAAwC,uCAAuC,oCAAoC,8FAA8F,qBAAqB,mBAAmB,mGAAmG,uBAAuB,kCAAkC,iBAAiB,gFAAgF,gBAAgB,gFAAgF,+CAA+C,sCAAsC,8BAA8B,kBAAkB,MAAM,+BAA+B,iBAAiB,eAAe,4BAA4B,8BAA8B,mFAAmF,sCAAsC,mDAAmD,eAAe,uCAAuC,+BAA+B,qCAAqC,qDAAqD,eAAe,cAAc,0CAA0C,gDAAgD,YAAY,wEAAwE,SAAS,mNAAmN,oCAAoC,wDAAwD,SAAS,+CAA+C,yMAAyM,2BAA2B,cAAc,QAAQ,+CAA+C,WAAW,wBAAwB,SAAS,yGAAyG,uDAAuD,kEAAkE,0DAA0D,2BAA2B,QAAQ,EAAE,6FAA6F,iOAAiO,EAAE,wMAAwM,6FAA6F,OAAO,sGAAsG,mGAAmG,8LAA8L,2CAA2C,gBAAgB,eAAe,8FAA8F,WAAW,wBAAwB,SAAS,QAAQ,EAAE,yQAAyQ,uEAAuE,OAAO,oGAAoG,qOAAqO,yGAAyG,SAAS,iFAAiF,EAAE,oRAAoR,uEAAuE,OAAO,+FAA+F,ySAAyS,EAAE,kQAAkQ,uEAAuE,OAAO,gGAAgG,mKAAmK,EAAE,oYAAoY,6FAA6F,+BAA+B,6BAA6B,6BAA6B,6BAA6B,OAAO,2FAA2F,iEAAiE,0FAA0F,oDAAoD,2JAA2J,sCAAsC,wDAAwD,yFAAyF,kCAAkC,sBAAsB,yHAAyH,yDAAyD,sBAAsB,0HAA0H,yBAAyB,aAAa,WAAW,sCAAsC,sDAAsD,yFAAyF,kCAAkC,sBAAsB,6GAA6G,6CAA6C,sBAAsB,+HAA+H,yBAAyB,aAAa,WAAW,2EAA2E,qDAAqD,mDAAmD,0CAA0C,0CAA0C,SAAS,mDAAmD,wWAAwW,sFAAsF,qFAAqF,kEAAkE,oCAAoC,6DAA6D,cAAc,QAAQ,4KAA4K,WAAW,wBAAwB,SAAS,QAAQ,EAAE,oIAAoI,6FAA6F,OAAO,4FAA4F,yFAAyF,sQAAsQ,2BAA2B,cAAc,QAAQ,sHAAsH,WAAW,wBAAwB,SAAS,QAAQ,EAAE,uPAAuP,6FAA6F,OAAO,8FAA8F,iGAAiG,iDAAiD,SAAS,QAAQ,EAAE,8JAA8J,wHAAwH,uDAAuD,kQAAkQ,WAAW,yCAAyC,SAAS,0GAA0G,kIAAkI,6DAA6D,sCAAsC,gCAAgC,sDAAsD,wBAAwB,4CAA4C,6FAA6F,SAAS,gHAAgH,wCAAwC,2CAA2C,WAAW,+BAA+B,oCAAoC,yBAAyB,SAAS,uBAAuB,qCAAqC,wBAAwB,SAAS,wIAAwI,sCAAsC,uDAAuD,0CAA0C,uBAAuB,QAAQ,gDAAgD,6BAA6B,cAAc,QAAQ,+DAA+D,aAAa,WAAW,wBAAwB,SAAS,iIAAiI,yCAAyC,iFAAiF,mCAAmC,WAAW,2CAA2C,yDAAyD,2CAA2C,mDAAmD,gBAAgB,+CAA+C,0CAA0C,uCAAuC,kDAAkD,mCAAmC,qCAAqC,cAAc,4BAA4B,YAAY,yCAAyC,uDAAuD,+CAA+C,0CAA0C,uCAAuC,qDAAqD,eAAe,qCAAqC,cAAc,4BAA4B,YAAY,MAAM,mDAAmD,+CAA+C,0CAA0C,uCAAuC,mCAAmC,eAAe,qCAAqC,cAAc,4BAA4B,WAAW,SAAS,QAAQ,qRAAqR,oGAAoG,qIAAqI,yBAAyB,+EAA+E,gFAAgF,4EAA4E,wBAAwB,sBAAsB,OAAO,6DAA6D,8JAA8J,0CAA0C,0FAA0F,WAAW,mFAAmF,2CAA2C,wCAAwC,4EAA4E,+BAA+B,+BAA+B,WAAW,2GAA2G,2CAA2C,YAAY,MAAM,oKAAoK,WAAW,SAAS,qCAAqC,4CAA4C,mBAAmB,6GAA6G,6CAA6C,YAAY,MAAM,uFAAuF,8LAA8L,yDAAyD,iEAAiE,iDAAiD,aAAa,WAAW,2CAA2C,kCAAkC,SAAS,+DAA+D,6CAA6C,mKAAmK,8IAA8I,iEAAiE,2EAA2E,2FAA2F,mEAAmE,WAAW,sFAAsF,SAAS,QAAQ,EAAE,+CAA+C,6NAA6N,iGAAiG,SAAS,8DAA8D,+FAA+F,SAAS,8DAA8D,8FAA8F,SAAS,uDAAuD,4BAA4B,oCAAoC,yGAAyG,oBAAoB,qGAAqG,oBAAoB,qGAAqG,oBAAoB,WAAW,8CAA8C,sIAAsI,yDAAyD,6IAA6I,mEAAmE,gBAAgB,MAAM,4CAA4C,qCAAqC,aAAa,4DAA4D,iBAAiB,WAAW,iDAAiD,SAAS,wCAAwC,6CAA6C,gGAAgG,4FAA4F,4FAA4F,WAAW,SAAS,oCAAoC,wDAAwD,SAAS,yGAAyG,qCAAqC,mCAAmC,+CAA+C,SAAS,QAAQ,uCAAuC,aAAa,WAAW,sBAAsB,SAAS,gIAAgI,oCAAoC,mCAAmC,+CAA+C,SAAS,QAAQ,sCAAsC,aAAa,WAAW,sBAAsB,SAAS,mTAAmT,4GAA4G,iEAAiE,oBAAoB,WAAW,yDAAyD,kBAAkB,WAAW,iBAAiB,4EAA4E,0IAA0I,6CAA6C,oEAAoE,6FAA6F,WAAW,sBAAsB,SAAS,6IAA6I,2BAA2B,8CAA8C,0DAA0D,uFAAuF,wBAAwB,WAAW,iGAAiG,8BAA8B,0EAA0E,wBAAwB,WAAW,8BAA8B,2BAA2B,aAAa,QAAQ,sCAAsC,sEAAsE,qGAAqG,0BAA0B,kBAAkB,aAAa,6DAA6D,sGAAsG,0BAA0B,kBAAkB,aAAa,gCAAgC,WAAW,uCAAuC,0DAA0D,kDAAkD,SAAS,QAAQ,wCAAwC,uCAAuC,uGAAuG,8BAA8B,sBAAsB,iBAAiB,eAAe,aAAa,WAAW,uBAAuB,SAAS,uKAAuK,yPAAyP,2BAA2B,eAAe,QAAQ,6BAA6B,kCAAkC,wCAAwC,8IAA8I,4CAA4C,mMAAmM,iCAAiC,cAAc,QAAQ,mDAAmD,8GAA8G,gCAAgC,wBAAwB,mBAAmB,iBAAiB,gBAAgB,MAAM,4BAA4B,eAAe,aAAa,2DAA2D,uCAAuC,iDAAiD,8FAA8F,iCAAiC,cAAc,QAAQ,uEAAuE,iBAAiB,eAAe,4BAA4B,aAAa,WAAW,yFAAyF,qDAAqD,iGAAiG,cAAc,QAAQ,mEAAmE,aAAa,0BAA0B,WAAW,8CAA8C,2EAA2E,oFAAoF,WAAW,sBAAsB,SAAS,QAAQ,EAAE,yQAAyQ,uEAAuE,OAAO,gGAAgG,mKAAmK,EAAE,4OAA4O,yBAAyB,2BAA2B,kEAAkE,yCAAyC,8GAA8G,+BAA+B,SAAS,wBAAwB,OAAO,qCAAqC,kCAAkC,6GAA6G,kDAAkD,SAAS,QAAQ,qFAAqF,WAAW,uEAAuE,SAAS,oCAAoC,6DAA6D,sBAAsB,wGAAwG,kDAAkD,SAAS,QAAQ,mEAAmE,WAAW,sBAAsB,SAAS,6FAA6F,2DAA2D,wBAAwB,2BAA2B,qBAAqB,QAAQ,2BAA2B,0BAA0B,yIAAyI,mCAAmC,iEAAiE,gEAAgE,kEAAkE,wKAAwK,4CAA4C,uCAAuC,aAAa,wMAAwM,WAAW,wDAAwD,SAAS,2DAA2D,4CAA4C,uDAAuD,sCAAsC,0EAA0E,WAAW,2BAA2B,sBAAsB,QAAQ,iDAAiD,oCAAoC,aAAa,WAAW,sBAAsB,SAAS,sFAAsF,2CAA2C,+KAA+K,gLAAgL,QAAQ,QAAQ,gDAAgD,wDAAwD,8CAA8C,oCAAoC,0EAA0E,4CAA4C,6EAA6E,eAAe,wDAAwD,aAAa,WAAW,yBAAyB,uDAAuD,4HAA4H,WAAW,uBAAuB,SAAS,qGAAqG,8BAA8B,qFAAqF,sBAAsB,WAAW,6GAA6G,yGAAyG,6BAA6B,4BAA4B,uFAAuF,mGAAmG,6EAA6E,eAAe,aAAa,YAAY,0BAA0B,qDAAqD,0GAA0G,sCAAsC,0DAA0D,2BAA2B,4BAA4B,QAAQ,0DAA0D,wGAAwG,sFAAsF,sGAAsG,+BAA+B,0BAA0B,QAAQ,wDAAwD,mCAAmC,4CAA4C,QAAQ,mFAAmF,mBAAmB,iBAAiB,eAAe,yOAAyO,+BAA+B,8BAA8B,iCAAiC,8CAA8C,QAAQ,wDAAwD,kDAAkD,wFAAwF,iBAAiB,0HAA0H,eAAe,kEAAkE,cAAc,MAAM,4GAA4G,sIAAsI,4IAA4I,mIAAmI,aAAa,WAAW,sCAAsC,wBAAwB,WAAW,qEAAqE,sBAAsB,SAAS,QAAQ,EAAE,+CAA+C,oCAAoC,iDAAiD,8CAA8C,SAAS,QAAQ,yCAAyC,mFAAmF,WAAW,mCAAmC,SAAS,4BAA4B,2BAA2B,wBAAwB,QAAQ,sDAAsD,WAAW,sBAAsB,SAAS,gCAAgC,2BAA2B,wBAAwB,QAAQ,wCAAwC,WAAW,sBAAsB,SAAS,QAAQ,EAAE,oGAAoG,mFAAmF,yBAAyB,OAAO,gDAAgD,6DAA6D,2BAA2B,uDAAuD,6CAA6C,wDAAwD,WAAW,wBAAwB,SAAS,0CAA0C,gCAAgC,SAAS,mCAAmC,uCAAuC,uCAAuC,mDAAmD,8EAA8E,aAAa,oCAAoC,WAAW,sDAAsD,mEAAmE,iEAAiE,4EAA4E,gFAAgF,gFAAgF,qFAAqF,qFAAqF,gFAAgF,gFAAgF,2GAA2G,6EAA6E,yFAAyF,+FAA+F,yFAAyF,8DAA8D,sFAAsF,6EAA6E,iEAAiE,0EAA0E,sFAAsF,gFAAgF,gFAAgF,mFAAmF,mFAAmF,gFAAgF,2GAA2G,qGAAqG,wGAAwG,+EAA+E,0EAA0E,6EAA6E,0EAA0E,oEAAoE,+EAA+E,yFAAyF,gFAAgF,4EAA4E,6EAA6E,8GAA8G,sHAAsH,kGAAkG,+FAA+F,8CAA8C,4DAA4D,sCAAsC,WAAW,0FAA0F,gFAAgF,gGAAgG,+CAA+C,+CAA+C,2DAA2D,6HAA6H,aAAa,0EAA0E,WAAW,kHAAkH,wGAAwG,qGAAqG,yGAAyG,uGAAuG,sGAAsG,wGAAwG,sGAAsG,uFAAuF,2FAA2F,6FAA6F,wGAAwG,oFAAoF,+FAA+F,sGAAsG,0BAA0B,SAAS,QAAQ,EAAE,0GAA0G,mFAAmF,OAAO,sDAAsD,6DAA6D,2BAA2B,uDAAuD,6CAA6C,wDAAwD,WAAW,wBAAwB,SAAS,mCAAmC,8CAA8C,sCAAsC,sCAAsC,2EAA2E,oEAAoE,WAAW,gDAAgD,yCAAyC,8CAA8C,iFAAiF,sHAAsH,WAAW,oFAAoF,uCAAuC,gDAAgD,SAAS,QAAQ,sCAAsC,iFAAiF,aAAa,WAAW,wDAAwD,+CAA+C,uCAAuC,wDAAwD,wDAAwD,aAAa,kFAAkF,WAAW,0BAA0B,SAAS,QAAQ,EAAE,0BAA0B,gZAAgZ,4FAA4F,0CAA0C,2CAA2C,2CAA2C,OAAO,yBAAyB,8DAA8D,8CAA8C,SAAS,iCAAiC,uCAAuC,gDAAgD,OAAO,UAAU,sCAAsC,yCAAyC,uCAAuC,4BAA4B,aAAa,WAAW,sBAAsB,SAAS,QAAQ,wCAAwC,wGAAwG,yBAAyB,2BAA2B,sBAAsB,QAAQ,yFAAyF,WAAW,uBAAuB,SAAS,wCAAwC,8BAA8B,yQAAyQ,kCAAkC,gDAAgD,kDAAkD,yEAAyE,6EAA6E,4EAA4E,gDAAgD,yDAAyD,0BAA0B,sCAAsC,kDAAkD,gBAAgB,MAAM,4DAA4D,uDAAuD,eAAe,2CAA2C,mDAAmD,wEAAwE,sEAAsE,eAAe,2CAA2C,mDAAmD,eAAe,yCAAyC,6EAA6E,mFAAmF,6EAA6E,mFAAmF,eAAe,+CAA+C,gDAAgD,eAAe,8CAA8C,yCAAyC,0BAA0B,aAAa,sCAAsC,0FAA0F,mCAAmC,oCAAoC,+BAA+B,0JAA0J,+DAA+D,sBAAsB,oFAAoF,sBAAsB,kKAAkK,sBAAsB,iGAAiG,sBAAsB,qGAAqG,sBAAsB,qGAAqG,sBAAsB,yEAAyE,sBAAsB,oHAAoH,uFAAuF,6FAA6F,sBAAsB,kKAAkK,sBAAsB,gLAAgL,+KAA+K,sBAAsB,oLAAoL,6JAA6J,sBAAsB,wKAAwK,2IAA2I,sBAAsB,4JAA4J,uJAAuJ,sBAAsB,yEAAyE,sBAAsB,oKAAoK,mKAAmK,sBAAsB,yFAAyF,sBAAsB,4KAA4K,+KAA+K,sBAAsB,oLAAoL,qLAAqL,sBAAsB,wLAAwL,qLAAqL,sBAAsB,wLAAwL,6JAA6J,sBAAsB,wKAAwK,oEAAoE,sBAAsB,wEAAwE,sBAAsB,0IAA0I,qCAAqC,sBAAsB,gSAAgS,sBAAsB,yGAAyG,uEAAuE,sBAAsB,+GAA+G,sBAAsB,eAAe,aAAa,0EAA0E,wEAAwE,4DAA4D,mDAAmD,gDAAgD,YAAY,UAAU,WAAW,EAAE,gGAAgG,wCAAwC,qDAAqD,qDAAqD,WAAW,kLAAkL,8CAA8C,QAAQ,QAAQ,iGAAiG,WAAW,mBAAmB,SAAS,2CAA2C,uCAAuC,gDAAgD,sBAAsB,yCAAyC,SAAS,QAAQ,mJAAmJ,6CAA6C,sGAAsG,4BAA4B,SAAS,mFAAmF,qCAAqC,OAAO,4CAA4C,6DAA6D,2BAA2B,gJAAgJ,sDAAsD,0DAA0D,6CAA6C,0CAA0C,uCAAuC,2CAA2C,uCAAuC,yCAAyC,wDAAwD,qHAAqH,uBAAuB,iBAAiB,uDAAuD,oHAAoH,uBAAuB,iBAAiB,eAAe,aAAa,0DAA0D,sDAAsD,WAAW,wBAAwB,SAAS,6CAA6C,mCAAmC,SAAS,+BAA+B,iDAAiD,kDAAkD,+CAA+C,aAAa,wkBAAwkB,6CAA6C,kEAAkE,qBAAqB,QAAQ,yDAAyD,eAAe,2BAA2B,eAAe,QAAQ,iDAAiD,eAAe,aAAa,uBAAuB,oCAAoC,wCAAwC,qCAAqC,uDAAuD,qDAAqD,qDAAqD,+CAA+C,aAAa,uBAAuB,iCAAiC,wCAAwC,wCAAwC,2CAA2C,8CAA8C,kDAAkD,gDAAgD,sDAAsD,+CAA+C,qDAAqD,mKAAmK,6BAA6B,oCAAoC,wCAAwC,4CAA4C,4CAA4C,oCAAoC,4CAA4C,4CAA4C,4CAA4C,4BAA4B,oCAAoC,qDAAqD,oDAAoD,oDAAoD,iBAAiB,qGAAqG,wCAAwC,+BAA+B,eAAe,QAAQ,4CAA4C,2DAA2D,6DAA6D,iCAAiC,OAAO,QAAQ,mDAAmD,iDAAiD,mDAAmD,+CAA+C,kFAAkF,oFAAoF,qBAAqB,mBAAmB,iBAAiB,sCAAsC,uDAAuD,qLAAqL,oDAAoD,iBAAiB,4CAA4C,+BAA+B,OAAO,QAAQ,yDAAyD,mMAAmM,wEAAwE,oEAAoE,mBAAmB,iBAAiB,uCAAuC,kDAAkD,2CAA2C,4CAA4C,0CAA0C,iBAAiB,6CAA6C,+BAA+B,OAAO,QAAQ,oDAAoD,6CAA6C,+EAA+E,6EAA6E,mBAAmB,iBAAiB,6CAA6C,2CAA2C,gBAAgB,MAAM,mCAAmC,0CAA0C,0CAA0C,0CAA0C,oCAAoC,qDAAqD,mDAAmD,iBAAiB,qGAAqG,wCAAwC,+BAA+B,eAAe,QAAQ,4CAA4C,2DAA2D,iCAAiC,OAAO,QAAQ,mDAAmD,iDAAiD,mDAAmD,+CAA+C,mEAAmE,qBAAqB,mBAAmB,iBAAiB,sCAAsC,uDAAuD,oLAAoL,iBAAiB,4CAA4C,+BAA+B,OAAO,QAAQ,yDAAyD,mMAAmM,sDAAsD,mBAAmB,iBAAiB,uCAAuC,kDAAkD,0DAA0D,iBAAiB,6CAA6C,+BAA+B,OAAO,QAAQ,oDAAoD,8EAA8E,mBAAmB,iBAAiB,4CAA4C,eAAe,aAAa,WAAW,gDAAgD,gHAAgH,qCAAqC,4DAA4D,OAAO,4BAA4B,8CAA8C,kFAAkF,kFAAkF,kFAAkF,uEAAuE,eAAe,aAAa,qCAAqC,4DAA4D,OAAO,4BAA4B,8CAA8C,kFAAkF,kFAAkF,kFAAkF,uEAAuE,eAAe,aAAa,wCAAwC,+LAA+L,0OAA0O,aAAa,WAAW,oDAAoD,mCAAmC,oDAAoD,6DAA6D,OAAO,QAAQ,gDAAgD,4EAA4E,uDAAuD,sEAAsE,gEAAgE,0DAA0D,QAAQ,UAAU,6CAA6C,oDAAoD,wDAAwD,wDAAwD,6CAA6C,iBAAiB,eAAe,aAAa,kFAAkF,kHAAkH,yCAAyC,2DAA2D,iDAAiD,OAAO,QAAQ,iEAAiE,eAAe,aAAa,WAAW,sDAAsD,sCAAsC,sFAAsF,iDAAiD,gDAAgD,aAAa,kDAAkD,6CAA6C,kEAAkE,gBAAgB,MAAM,mDAAmD,eAAe,aAAa,6BAA6B,uBAAuB,QAAQ,yFAAyF,sDAAsD,aAAa,sFAAsF,yQAAyQ,8EAA8E,aAAa,sFAAsF,WAAW,iDAAiD,4CAA4C,+DAA+D,aAAa,6CAA6C,4CAA4C,cAAc,MAAM,+BAA+B,aAAa,0CAA0C,yCAAyC,sCAAsC,0CAA0C,4CAA4C,0CAA0C,2CAA2C,gFAAgF,uBAAuB,qBAAqB,cAAc,MAAM,8GAA8G,uBAAuB,2CAA2C,aAAa,YAAY,UAAU,WAAW,EAAE,kGAAkG,mFAAmF,4BAA4B,OAAO,8CAA8C,6DAA6D,0CAA0C,8EAA8E,WAAW,2BAA2B,uDAAuD,6CAA6C,4BAA4B,iBAAiB,wCAAwC,cAAc,iBAAiB,4DAA4D,+FAA+F,qBAAqB,aAAa,yCAAyC,wHAAwH,6GAA6G,mBAAmB,aAAa,wCAAwC,WAAW,wBAAwB,SAAS,6CAA6C,mCAAmC,SAAS,6CAA6C,mCAAmC,SAAS,2CAA2C,sDAAsD,yEAAyE,mEAAmE,yDAAyD,YAAY,EAAE,qEAAqE,wEAAwE,8EAA8E,kCAAkC,wEAAwE,WAAW,wEAAwE,yDAAyD,WAAW,wBAAwB,SAAS,wCAAwC,0BAA0B,qCAAqC,8CAA8C,OAAO,QAAQ,4DAA4D,2CAA2C,aAAa,WAAW,wBAAwB,SAAS,qDAAqD,8BAA8B,qCAAqC,kDAAkD,gEAAgE,8CAA8C,OAAO,QAAQ,2BAA2B,iCAAiC,oCAAoC,8RAA8R,wBAAwB,sZAAsZ,wBAAwB,6RAA6R,wBAAwB,mbAAmb,wBAAwB,oYAAoY,wBAAwB,yYAAyY,wBAAwB,weAAwe,wBAAwB,yWAAyW,wBAAwB,0TAA0T,wBAAwB,yVAAyV,wBAAwB,uRAAuR,wBAAwB,8RAA8R,wBAAwB,wHAAwH,2DAA2D,OAAO,QAAQ,2DAA2D,iDAAiD,mBAAmB,gJAAgJ,wBAAwB,sGAAsG,wBAAwB,qHAAqH,wBAAwB,gIAAgI,2BAA2B,eAAe,wCAAwC,uEAAuE,iDAAiD,aAAa,WAAW,4BAA4B,SAAS,sDAAsD,6BAA6B,qCAAqC,8CAA8C,yCAAyC,8CAA8C,OAAO,QAAQ,mCAAmC,oDAAoD,4DAA4D,iCAAiC,2BAA2B,QAAQ,oEAAoE,iBAAiB,+CAA+C,gBAAgB,MAAM,8DAA8D,eAAe,aAAa,WAAW,2BAA2B,SAAS,6CAA6C,8BAA8B,2BAA2B,iBAAiB,QAAQ,wDAAwD,oCAAoC,WAAW,4BAA4B,SAAS,iDAAiD,2BAA2B,wBAAwB,qCAAqC,2CAA2C,kDAAkD,2CAA2C,aAAa,0BAA0B,2CAA2C,2CAA2C,cAAc,EAAE,WAAW,wDAAwD,uDAAuD,oDAAoD,oDAAoD,8CAA8C,OAAO,QAAQ,oCAAoC,qHAAqH,uDAAuD,aAAa,WAAW,wBAAwB,SAAS,mDAAmD,iDAAiD,0DAA0D,0GAA0G,iCAAiC,WAAW,4BAA4B,qCAAqC,8CAA8C,OAAO,QAAQ,mCAAmC,+CAA+C,4FAA4F,eAAe,yDAAyD,kFAAkF,eAAe,gEAAgE,uCAAuC,uCAAuC,sEAAsE,iHAAiH,uFAAuF,qFAAqF,qFAAqF,gFAAgF,8CAA8C,kFAAkF,gFAAgF,eAAe,sHAAsH,oHAAoH,sFAAsF,yEAAyE,8CAA8C,aAAa,WAAW,0BAA0B,SAAS,mCAAmC,qCAAqC,sEAAsE,uBAAuB,0CAA0C,uDAAuD,+EAA+E,eAAe,wCAAwC,aAAa,0CAA0C,yDAAyD,4CAA4C,+BAA+B,kDAAkD,OAAO,QAAQ,uCAAuC,0DAA0D,mFAAmF,mBAAmB,kDAAkD,iBAAiB,6BAA6B,eAAe,sDAAsD,+EAA+E,eAAe,uCAAuC,aAAa,kCAAkC,gEAAgE,sDAAsD,8DAA8D,qEAAqE,mBAAmB,iBAAiB,+CAA+C,kDAAkD,wFAAwF,oBAAoB,yCAAyC,iFAAiF,mBAAmB,iBAAiB,sBAAsB,oIAAoI,0EAA0E,qEAAqE,oFAAoF,uFAAuF,4EAA4E,cAAc,sBAAsB,6JAA6J,sBAAsB,0GAA0G,sBAAsB,kHAAkH,sBAAsB,iIAAiI,sBAAsB,qIAAqI,sBAAsB,0JAA0J,sBAAsB,kIAAkI,sBAAsB,sIAAsI,sFAAsF,0DAA0D,oEAAoE,iEAAiE,kBAAkB,MAAM,0DAA0D,iBAAiB,sBAAsB,4DAA4D,sBAAsB,qIAAqI,sBAAsB,kIAAkI,sBAAsB,0IAA0I,sBAAsB,4JAA4J,sBAAsB,gGAAgG,sBAAsB,gEAAgE,sBAAsB,8DAA8D,aAAa,oCAAoC,mEAAmE,4CAA4C,8CAA8C,iFAAiF,cAAc,MAAM,4FAA4F,0FAA0F,gGAAgG,iFAAiF,aAAa,qFAAqF,4FAA4F,gCAAgC,0FAA0F,8FAA8F,4GAA4G,kHAAkH,aAAa,4EAA4E,6EAA6E,gDAAgD,2CAA2C,+BAA+B,qBAAqB,QAAQ,uFAAuF,eAAe,aAAa,wCAAwC,uCAAuC,+BAA+B,mBAAmB,QAAQ,wCAAwC,6EAA6E,4CAA4C,2DAA2D,iBAAiB,eAAe,aAAa,0BAA0B,YAAY,SAAS,UAAU,EAAE,6BAA6B,mcAAmc,8BAA8B,8IAA8I,4BAA4B,qTAAqT,iHAAiH,yDAAyD,wFAAwF,SAAS,6CAA6C,4EAA4E,SAAS,+EAA+E,+BAA+B,OAAO,qCAAqC,2FAA2F,iCAAiC,sBAAsB,SAAS,kEAAkE,4CAA4C,+DAA+D,2BAA2B,wCAAwC,uCAAuC,2CAA2C,qCAAqC,6CAA6C,2CAA2C,aAAa,MAAM,0BAA0B,WAAW,+CAA+C,8BAA8B,YAAY,2BAA2B,4DAA4D,YAAY,kCAAkC,0CAA0C,gDAAgD,yCAAyC,YAAY,yBAAyB,wCAAwC,yCAAyC,yCAAyC,YAAY,EAAE,SAAS,mDAAmD,sBAAsB,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,2LAA2L,gCAAgC,2BAA2B,8BAA8B,OAAO,2CAA2C,mCAAmC,wCAAwC,+CAA+C,wCAAwC,SAAS,oCAAoC,0CAA0C,SAAS,4DAA4D,kEAAkE,SAAS,yEAAyE,+EAA+E,SAAS,uCAAuC,6CAA6C,SAAS,gDAAgD,kDAAkD,4BAA4B,oDAAoD,OAAO,QAAQ,4CAA4C,yCAAyC,6CAA6C,sCAAsC,aAAa,0BAA0B,WAAW,4DAA4D,2CAA2C,sUAAsU,4CAA4C,aAAa,YAAY,6CAA6C,4CAA4C,sDAAsD,oDAAoD,0DAA0D,gEAAgE,8CAA8C,kBAAkB,6CAA6C,kBAAkB,iBAAiB,wFAAwF,+CAA+C,gEAAgE,uDAAuD,8EAA8E,MAAM,uGAAuG,0DAA0D,gFAAgF,kCAAkC,sDAAsD,gBAAgB,MAAM,iGAAiG,+PAA+P,uDAAuD,eAAe,aAAa,2BAA2B,WAAW,mDAAmD,uCAAuC,+CAA+C,uEAAuE,sDAAsD,wCAAwC,oCAAoC,iCAAiC,2CAA2C,kCAAkC,wBAAwB,WAAW,sEAAsE,uDAAuD,sDAAsD,oCAAoC,2BAA2B,+BAA+B,wBAAwB,sBAAsB,2CAA2C,sCAAsC,gDAAgD,OAAO,QAAQ,oCAAoC,0CAA0C,2CAA2C,0CAA0C,0BAA0B,8EAA8E,uCAAuC,+BAA+B,2DAA2D,4CAA4C,0CAA0C,qCAAqC,cAAc,MAAM,+CAA+C,gCAAgC,EAAE,sCAAsC,aAAa,WAAW,2IAA2I,yCAAyC,kCAAkC,4BAA4B,yDAAyD,aAAa,WAAW,4CAA4C,aAAa,yDAAyD,aAAa,WAAW,8CAA8C,kCAAkC,mBAAmB,WAAW,qCAAqC,yCAAyC,qCAAqC,0BAA0B,YAAY,6EAA6E,4DAA4D,sCAAsC,EAAE,0CAA0C,8CAA8C,yDAAyD,sBAAsB,MAAM,uCAAuC,qBAAqB,mBAAmB,iBAAiB,sCAAsC,sDAAsD,iBAAiB,eAAe,aAAa,qDAAqD,sCAAsC,wDAAwD,iEAAiE,aAAa,WAAW,uBAAuB,kDAAkD,QAAQ,QAAQ,wCAAwC,kCAAkC,wCAAwC,mDAAmD,QAAQ,QAAQ,qDAAqD,aAAa,WAAW,2CAA2C,wBAAwB,SAAS,QAAQ,EAAE,+IAA+I,2BAA2B,yBAAyB,OAAO,sCAAsC,iFAAiF,wCAAwC,mDAAmD,6CAA6C,gHAAgH,yCAAyC,2BAA2B,6BAA6B,kBAAkB,QAAQ,oCAAoC,qCAAqC,4BAA4B,qCAAqC,gBAAgB,MAAM,sEAAsE,qCAAqC,qCAAqC,eAAe,aAAa,yBAAyB,WAAW,6DAA6D,+DAA+D,kCAAkC,uCAAuC,yBAAyB,wEAAwE,4BAA4B,oGAAoG,mDAAmD,OAAO,GAAG,6CAA6C,mCAAmC,+FAA+F,wDAAwD,wCAAwC,0BAA0B,+FAA+F,wDAAwD,wCAAwC,0BAA0B,2GAA2G,0DAA0D,2DAA2D,2DAA2D,kEAAkE,kDAAkD,kCAAkC,qCAAqC,mCAAmC,2CAA2C,0BAA0B,wGAAwG,0DAA0D,2DAA2D,2DAA2D,2DAA2D,2DAA2D,2EAA2E,kDAAkD,kCAAkC,qCAAqC,mCAAmC,2CAA2C,0BAA0B,iBAAiB,eAAe,aAAa,qBAAqB,wCAAwC,WAAW,2DAA2D,qDAAqD,+BAA+B,0CAA0C,wBAAwB,8CAA8C,QAAQ,QAAQ,wEAAwE,WAAW,wBAAwB,SAAS,QAAQ,EAAE,gGAAgG,mFAAmF,OAAO,4CAA4C,6DAA6D,2BAA2B,sDAAsD,oCAAoC,6CAA6C,qBAAqB,iBAAiB,wCAAwC,cAAc,aAAa,sHAAsH,uEAAuE,aAAa,2CAA2C,yCAAyC,WAAW,wBAAwB,SAAS,mCAAmC,kCAAkC,SAAS,sCAAsC,4BAA4B,oBAAoB,SAAS,QAAQ,EAAE,4EAA4E,0BAA0B,iCAAiC,wCAAwC,iFAAiF,WAAW,yBAAyB,SAAS,yCAAyC,0BAA0B,SAAS,QAAQ,oHAAoH,mFAAmF,OAAO,6CAA6C,6DAA6D,sDAAsD,gDAAgD,+CAA+C,oDAAoD,uEAAuE,oCAAoC,cAAc,EAAE,WAAW,wBAAwB,SAAS,QAAQ,EAAE,yFAAyF,mCAAmC,wBAAwB,4BAA4B,+CAA+C,sCAAsC,4CAA4C,+CAA+C,sCAAsC,4CAA4C,OAAO,8CAA8C,+BAA+B,oEAAoE,uCAAuC,oCAAoC,4CAA4C,gSAAgS,gCAAgC,8BAA8B,iCAAiC,6BAA6B,iDAAiD,+BAA+B,6BAA6B,+BAA+B,4LAA4L,qCAAqC,2DAA2D,+EAA+E,2BAA2B,kFAAkF,6CAA6C,uFAAuF,sDAAsD,0EAA0E,+EAA+E,qEAAqE,wFAAwF,sDAAsD,0EAA0E,+EAA+E,qEAAqE,aAAa,oFAAoF,mFAAmF,YAAY,UAAU,WAAW,EAAE,oNAAoN,8BAA8B,iCAAiC,iCAAiC,uEAAuE,mCAAmC,gDAAgD,2BAA2B,uEAAuE,mCAAmC,kDAAkD,2BAA2B,uEAAuE,iCAAiC,gDAAgD,2BAA2B,uEAAuE,mCAAmC,kDAAkD,2BAA2B,uEAAuE,mCAAmC,gDAAgD,2BAA2B,uEAAuE,mCAAmC,kDAAkD,2BAA2B,wBAAwB,sEAAsE,iGAAiG,sDAAsD,oDAAoD,+DAA+D,+CAA+C,mEAAmE,uDAAuD,0CAA0C,yDAAyD,0CAA0C,yDAAyD,0CAA0C,yDAAyD,0CAA0C,yDAAyD,0CAA0C,yDAAyD,iEAAiE,0CAA0C,yDAAyD,2CAA2C,UAAU,mEAAmE,+CAA+C,2BAA2B,OAAO,QAAQ,4CAA4C,mDAAmD,oDAAoD,WAAW,2CAA2C,UAAU,OAAO,iEAAiE,kDAAkD,0FAA0F,8BAA8B,oCAAoC,iDAAiD,8CAA8C,oDAAoD,2BAA2B,OAAO,qFAAqF,kEAAkE,2BAA2B,SAAS,qCAAqC,uCAAuC,gDAAgD,6DAA6D,wDAAwD,6BAA6B,WAAW,SAAS,iCAAiC,6BAA6B,SAAS,wCAAwC,uCAAuC,gDAAgD,6DAA6D,YAAY,MAAM,6DAA6D,WAAW,8BAA8B,yCAAyC,wDAAwD,SAAS,uCAAuC,sCAAsC,SAAS,8CAA8C,uCAAuC,SAAS,2CAA2C,uCAAuC,0CAA0C,kCAAkC,0CAA0C,sDAAsD,qEAAqE,iDAAiD,2BAA2B,sEAAsE,uEAAuE,uCAAuC,wFAAwF,sFAAsF,sFAAsF,wFAAwF,wFAAwF,wFAAwF,0EAA0E,0EAA0E,0EAA0E,cAAc,MAAM,yEAAyE,qGAAqG,aAAa,YAAY,UAAU,WAAW,EAAE,yJAAyJ,8BAA8B,4BAA4B,wCAAwC,8CAA8C,+CAA+C,8BAA8B,2BAA2B,wBAAwB,yBAAyB,sBAAsB,4BAA4B,6BAA6B,qCAAqC,gCAAgC,0BAA0B,OAAO,6EAA6E,2DAA2D,2BAA2B,SAAS,gDAAgD,0CAA0C,sCAAsC,gCAAgC,uBAAuB,sBAAsB,SAAS,8CAA8C,oCAAoC,mCAAmC,2CAA2C,sBAAsB,SAAS,4BAA4B,0CAA0C,qEAAqE,iBAAiB,WAAW,oDAAoD,+EAA+E,iBAAiB,WAAW,yDAAyD,sCAAsC,gCAAgC,mDAAmD,gFAAgF,kDAAkD,oDAAoD,gCAAgC,+BAA+B,gCAAgC,SAAS,6BAA6B,oDAAoD,+EAA+E,iBAAiB,WAAW,0CAA0C,+BAA+B,2FAA2F,iCAAiC,WAAW,sBAAsB,SAAS,4BAA4B,oDAAoD,+EAA+E,iBAAiB,WAAW,6BAA6B,wBAAwB,+BAA+B,sBAAsB,SAAS,+BAA+B,0CAA0C,qDAAqD,sDAAsD,OAAO,QAAQ,iEAAiE,aAAa,gFAAgF,YAAY,MAAM,oDAAoD,WAAW,sBAAsB,SAAS,kCAAkC,0CAA0C,wDAAwD,sDAAsD,OAAO,QAAQ,oEAAoE,aAAa,mFAAmF,YAAY,MAAM,uDAAuD,WAAW,sBAAsB,SAAS,kCAAkC,8BAA8B,SAAS,yCAAyC,oCAAoC,0CAA0C,8BAA8B,+BAA+B,yBAAyB,YAAY,MAAM,iCAAiC,WAAW,sBAAsB,SAAS,iCAAiC,wCAAwC,SAAS,yCAAyC,6DAA6D,SAAS,8CAA8C,oDAAoD,+EAA+E,iBAAiB,WAAW,oCAAoC,0CAA0C,mGAAmG,WAAW,sBAAsB,SAAS,uCAAuC,mCAAmC,SAAS,+BAA+B,iCAAiC,SAAS,+BAA+B,oDAAoD,+EAA+E,uBAAuB,WAAW,2BAA2B,SAAS,sCAAsC,oDAAoD,+EAA+E,iBAAiB,WAAW,4BAA4B,0CAA0C,yCAAyC,WAAW,sBAAsB,SAAS,iCAAiC,sCAAsC,SAAS,wCAAwC,uCAAuC,sBAAsB,SAAS,QAAQ,EAAE,sGAAsG,qCAAqC,kDAAkD,uCAAuC,OAAO,oFAAoF,qEAAqE,6BAA6B,SAAS,sCAAsC,yCAAyC,SAAS,6CAA6C,0CAA0C,SAAS,wCAAwC,2CAA2C,SAAS,+CAA+C,4CAA4C,SAAS,wCAAwC,2CAA2C,SAAS,+CAA+C,4CAA4C,SAAS,sCAAsC,yCAAyC,SAAS,6CAA6C,0CAA0C,SAAS,2CAA2C,uCAAuC,sDAAsD,qEAAqE,+DAA+D,0EAA0E,YAAY,UAAU,aAAa,EAAE,0GAA0G,uDAAuD,qEAAqE,sEAAsE,mDAAmD,OAAO,+CAA+C,uCAAuC,0DAA0D,2BAA2B,SAAS,2CAA2C,wDAAwD,2BAA2B,iBAAiB,QAAQ,+BAA+B,WAAW,qCAAqC,SAAS,QAAQ,EAAE,yRAAyR,+BAA+B,iCAAiC,0DAA0D,6BAA6B,gEAAgE,gBAAgB,yEAAyE,qCAAqC,gBAAgB,qDAAqD,SAAS,sDAAsD,qZAAqZ,kCAAkC,0BAA0B,8BAA8B,OAAO,+CAA+C,oHAAoH,gUAAgU,sCAAsC,sEAAsE,cAAc,QAAQ,iDAAiD,aAAa,mCAAmC,YAAY,MAAM,qFAAqF,2CAA2C,kEAAkE,WAAW,gDAAgD,SAAS,8GAA8G,kMAAkM,oCAAoC,6BAA6B,oHAAoH,wGAAwG,WAAW,qDAAqD,SAAS,QAAQ,yDAAyD,yGAAyG,kBAAkB,aAAa,WAAW,SAAS,oHAAoH,qCAAqC,kHAAkH,0DAA0D,uIAAuI,SAAS,QAAQ,yEAAyE,WAAW,oCAAoC,SAAS,4HAA4H,uDAAuD,kEAAkE,SAAS,kGAAkG,2BAA2B,6BAA6B,cAAc,QAAQ,gEAAgE,aAAa,WAAW,SAAS,+DAA+D,6FAA6F,SAAS,sEAAsE,wBAAwB,2BAA2B,cAAc,QAAQ,kCAAkC,wEAAwE,WAAW,SAAS,QAAQ,EAAE,gRAAgR,sFAAsF,wCAAwC,kEAAkE,OAAO,2CAA2C,8CAA8C,uBAAuB,2IAA2I,wHAAwH,SAAS,+CAA+C,wCAAwC,6FAA6F,SAAS,QAAQ,oDAAoD,WAAW,SAAS,4BAA4B,wCAAwC,6FAA6F,SAAS,QAAQ,iCAAiC,WAAW,SAAS,8BAA8B,wCAAwC,6FAA6F,SAAS,QAAQ,mCAAmC,WAAW,SAAS,QAAQ,EAAE,gEAAgE,yBAAyB,6EAA6E,+FAA+F,iCAAiC,OAAO,uCAAuC,kFAAkF,4DAA4D,iEAAiE,YAAY,MAAM,2EAA2E,WAAW,SAAS,0LAA0L,QAAQ,iDAAiD,OAAO,oDAAoD,uEAAuE,SAAS,sCAAsC,+LAA+L,uHAAuH,uNAAuN,uLAAuL,6LAA6L,0EAA0E,yCAAyC,oDAAoD,8BAA8B,yFAAyF,aAAa,2BAA2B,2RAA2R,kFAAkF,6DAA6D,yEAAyE,6VAA6V,4EAA4E,8CAA8C,eAAe,aAAa,uFAAuF,4GAA4G,aAAa,2BAA2B,YAAY,SAAS,kDAAkD,yKAAyK,wBAAwB,WAAW,sEAAsE,wDAAwD,+BAA+B,2BAA2B,QAAQ,+CAA+C,+CAA+C,8BAA8B,iBAAiB,eAAe,0BAA0B,cAAc,uDAAuD,yBAAyB,0BAA0B,aAAa,WAAW,oEAAoE,2DAA2D,+BAA+B,qBAAqB,QAAQ,8CAA8C,mFAAmF,mCAAmC,iBAAiB,qEAAqE,4CAA4C,eAAe,0BAA0B,cAAc,iEAAiE,gCAAgC,iCAAiC,aAAa,WAAW,sBAAsB,SAAS,QAAQ,EAAE,kDAAkD,8HAA8H,4CAA4C,uBAAuB,iGAAiG,sBAAsB,+EAA+E,qFAAqF,8DAA8D,WAAW,sDAAsD,+CAA+C,gDAAgD,SAAS,QAAQ,gDAAgD,aAAa,WAAW,6DAA6D,2EAA2E,WAAW,wDAAwD,4DAA4D,WAAW,2IAA2I,wEAAwE,aAAa,wEAAwE,wEAAwE,iDAAiD,aAAa,mFAAmF,wEAAwE,4DAA4D,aAAa,+FAA+F,+CAA+C,gDAAgD,SAAS,QAAQ,gDAAgD,eAAe,aAAa,uEAAuE,+CAA+C,gDAAgD,SAAS,QAAQ,gDAAgD,eAAe,mDAAmD,aAAa,kFAAkF,+CAA+C,gDAAgD,SAAS,QAAQ,gDAAgD,eAAe,8DAA8D,aAAa,uGAAuG,6EAA6E,aAAa,8EAA8E,6EAA6E,iDAAiD,aAAa,yFAAyF,6EAA6E,4DAA4D,aAAa,sGAAsG,gEAAgE,aAAa,2EAA2E,gEAAgE,iDAAiD,aAAa,sFAAsF,gEAAgE,4DAA4D,aAAa,yFAAyF,sBAAsB,6CAA6C,2TAA2T,qEAAqE,sBAAsB,6CAA6C,SAAS,kGAAkG,iOAAiO,iCAAiC,2GAA2G,qCAAqC,WAAW,+GAA+G,mDAAmD,wEAAwE,gIAAgI,iBAAiB,WAAW,6BAA6B,qDAAqD,2IAA2I,+EAA+E,6HAA6H,uBAAuB,iBAAiB,0DAA0D,uJAAuJ,uBAAuB,iBAAiB,+DAA+D,sBAAsB,2EAA2E,0HAA0H,uBAAuB,iBAAiB,+NAA+N,mGAAmG,yBAAyB,QAAQ,iEAAiE,oCAAoC,wBAAwB,mBAAmB,iBAAiB,sBAAsB,uFAAuF,gHAAgH,uBAAuB,iBAAiB,0DAA0D,aAAa,gDAAgD,gEAAgE,6IAA6I,qBAAqB,eAAe,yDAAyD,aAAa,WAAW,qFAAqF,6CAA6C,+CAA+C,iLAAiL,iBAAiB,WAAW,sFAAsF,0DAA0D,gEAAgE,2CAA2C,YAAY,gEAAgE,iFAAiF,2CAA2C,WAAW,oGAAoG,8CAA8C,kKAAkK,0PAA0P,6IAA6I,qBAAqB,eAAe,6DAA6D,gEAAgE,+JAA+J,uBAAuB,iBAAiB,iCAAiC,wDAAwD,QAAQ,qGAAqG,sCAAsC,wBAAwB,mBAAmB,iBAAiB,kBAAkB,MAAM,6DAA6D,4JAA4J,uBAAuB,iBAAiB,iCAAiC,4CAA4C,QAAQ,yFAAyF,sCAAsC,wBAAwB,mBAAmB,iBAAiB,eAAe,aAAa,wDAAwD,iDAAiD,6CAA6C,YAAY,wFAAwF,oHAAoH,iDAAiD,YAAY,2CAA2C,uDAAuD,iDAAiD,YAAY,MAAM,6CAA6C,WAAW,mGAAmG,2FAA2F,SAAS,8BAA8B,2BAA2B,oLAAoL,+CAA+C,SAAS,QAAQ,EAAE,iGAAiG,2LAA2L,EAAE,q3BAAq3B,yCAAyC,mHAAmH,iCAAiC,2FAA2F,oCAAoC,qEAAqE,SAAS,QAAQ,6CAA6C,SAAS,yBAAyB,wDAAwD,qBAAqB,qBAAqB,2BAA2B,mFAAmF,6DAA6D,sBAAsB,oBAAoB,uBAAuB,2CAA2C,aAAa,wBAAwB,wDAAwD,aAAa,SAAS,kCAAkC,0CAA0C,WAAW,UAAU,OAAO,sDAAsD,+DAA+D,0TAA0T,iDAAiD,SAAS,QAAQ,qJAAqJ,wCAAwC,gGAAgG,0CAA0C,mCAAmC,mHAAmH,SAAS,QAAQ,kGAAkG,eAAe,cAAc,oCAAoC,6CAA6C,8KAA8K,6DAA6D,gDAAgD,uDAAuD,iDAAiD,mHAAmH,SAAS,QAAQ,wKAAwK,sDAAsD,8CAA8C,4PAA4P,iBAAiB,8DAA8D,eAAe,cAAc,8CAA8C,wMAAwM,cAAc,gEAAgE,gEAAgE,SAAS,8BAA8B,8MAA8M,iDAAiD,SAAS,QAAQ,iHAAiH,mEAAmE,+KAA+K,8DAA8D,iDAAiD,sDAAsD,gDAAgD,mHAAmH,SAAS,QAAQ,wKAAwK,uDAAuD,2DAA2D,eAAe,aAAa,YAAY,gEAAgE,SAAS,uDAAuD,kPAAkP,iDAAiD,SAAS,QAAQ,iHAAiH,wCAAwC,2CAA2C,6CAA6C,+QAA+Q,4HAA4H,kDAAkD,mIAAmI,uDAAuD,4BAA4B,uHAAuH,SAAS,QAAQ,+KAA+K,wDAAwD,2DAA2D,sCAAsC,iBAAiB,gBAAgB,MAAM,kKAAkK,yDAAyD,4CAA4C,4BAA4B,uHAAuH,SAAS,QAAQ,sDAAsD,0EAA0E,sCAAsC,iBAAiB,gBAAgB,iCAAiC,iCAAiC,gEAAgE,SAAS,+HAA+H,4QAA4Q,8DAA8D,oPAAoP,kCAAkC,wCAAwC,6BAA6B,uCAAuC,yCAAyC,4DAA4D,SAAS,QAAQ,sCAAsC,iFAAiF,WAAW,iCAAiC,SAAS,0CAA0C,6OAA6O,sCAAsC,4RAA4R,sDAAsD,6CAA6C,yBAAyB,oEAAoE,4BAA4B,wDAAwD,sBAAsB,WAAW,SAAS,QAAQ,EAAE,8SAA8S,4BAA4B,wBAAwB,0CAA0C,6GAA6G,mCAAmC,uFAAuF,yBAAyB,eAAe,QAAQ,kEAAkE,wCAAwC,mDAAmD,SAAS,wDAAwD,0CAA0C,kIAAkI,gCAAgC,mEAAmE,uEAAuE,qCAAqC,+BAA+B,4BAA4B,mJAAmJ,oIAAoI,2BAA2B,mCAAmC,wBAAwB,gCAAgC,qCAAqC,kEAAkE,sEAAsE,kFAAkF,wEAAwE,gFAAgF,2CAA2C,iDAAiD,wDAAwD,8CAA8C,sBAAsB,SAAS,4BAA4B,gDAAgD,8BAA8B,SAAS,6BAA6B,8BAA8B,4BAA4B,wBAAwB,mDAAmD,yDAAyD,uEAAuE,SAAS,iCAAiC,qJAAqJ,SAAS,iFAAiF,qDAAqD,SAAS,qCAAqC,iCAAiC,sBAAsB,SAAS,kDAAkD,2BAA2B,uCAAuC,sBAAsB,SAAS,4QAA4Q,+BAA+B,kHAAkH,mCAAmC,SAAS,oGAAoG,uCAAuC,SAAS,wCAAwC,wDAAwD,SAAS,yCAAyC,wDAAwD,SAAS,oEAAoE,4CAA4C,gCAAgC,uBAAuB,4OAA4O,+DAA+D,oDAAoD,WAAW,sBAAsB,SAAS,iEAAiE,oEAAoE,SAAS,kCAAkC,0DAA0D,6CAA6C,2CAA2C,uEAAuE,WAAW,sBAAsB,SAAS,oSAAoS,qCAAqC,+DAA+D,oCAAoC,SAAS,2GAA2G,0CAA0C,SAAS,6CAA6C,0DAA0D,oCAAoC,SAAS,wCAAwC,kCAAkC,0CAA0C,oCAAoC,SAAS,sCAAsC,oEAAoE,SAAS,oEAAoE,8IAA8I,uCAAuC,0DAA0D,mDAAmD,WAAW,iGAAiG,2BAA2B,oCAAoC,mDAAmD,+CAA+C,sBAAsB,SAAS,mCAAmC,gEAAgE,gDAAgD,8CAA8C,0EAA0E,WAAW,sBAAsB,SAAS,2DAA2D,6BAA6B,SAAS,+BAA+B,4BAA4B,SAAS,+BAA+B,sDAAsD,SAAS,4FAA4F,iEAAiE,uGAAuG,iBAAiB,WAAW,0CAA0C,qCAAqC,qHAAqH,yDAAyD,sBAAsB,yDAAyD,wDAAwD,+DAA+D,WAAW,mGAAmG,qDAAqD,uJAAuJ,6BAA6B,kDAAkD,sDAAsD,sDAAsD,SAAS,QAAQ,qDAAqD,gEAAgE,aAAa,WAAW,SAAS,2CAA2C,yBAAyB,+BAA+B,iCAAiC,oDAAoD,yCAAyC,uEAAuE,yCAAyC,iEAAiE,kCAAkC,+CAA+C,4EAA4E,iBAAiB,eAAe,aAAa,WAAW,yCAAyC,sBAAsB,SAAS,8CAA8C,4BAA4B,gCAAgC,uCAAuC,yDAAyD,yCAAyC,uEAAuE,4CAA4C,iEAAiE,mCAAmC,wCAAwC,gFAAgF,kBAAkB,MAAM,kGAAkG,iBAAiB,eAAe,aAAa,WAAW,+CAA+C,yBAAyB,SAAS,8CAA8C,2CAA2C,6CAA6C,gHAAgH,oCAAoC,sCAAsC,+DAA+D,kDAAkD,aAAa,0BAA0B,uCAAuC,gCAAgC,gBAAgB,sBAAsB,yBAAyB,gBAAgB,uBAAuB,+DAA+D,sCAAsC,0CAA0C,2GAA2G,EAAE,aAAa,YAAY,OAAO,qFAAqF,sCAAsC,kEAAkE,8BAA8B,2EAA2E,gBAAgB,MAAM,qPAAqP,eAAe,aAAa,iDAAiD,yFAAyF,kDAAkD,iDAAiD,yDAAyD,kCAAkC,uIAAuI,wCAAwC,oDAAoD,4CAA4C,iHAAiH,EAAE,gBAAgB,MAAM,qEAAqE,0FAA0F,iEAAiE,kBAAkB,MAAM,6DAA6D,iBAAiB,4CAA4C,4CAA4C,gFAAgF,EAAE,eAAe,aAAa,wDAAwD,kFAAkF,mCAAmC,aAAa,WAAW,2BAA2B,oBAAoB,SAAS,6DAA6D,mDAAmD,2BAA2B,qDAAqD,kDAAkD,YAAY,MAAM,yFAAyF,mGAAmG,cAAc,MAAM,sDAAsD,aAAa,0BAA0B,+FAA+F,cAAc,MAAM,uDAAuD,aAAa,WAAW,SAAS,wEAAwE,oGAAoG,uCAAuC,0DAA0D,gDAAgD,WAAW,iGAAiG,4BAA4B,gCAAgC,oCAAoC,2BAA2B,sBAAsB,SAAS,QAAQ,EAAE,4NAA4N,0BAA0B,gCAAgC,0BAA0B,sBAAsB,6BAA6B,OAAO,6FAA6F,+FAA+F,sWAAsW,+CAA+C,gCAAgC,sDAAsD,WAAW,2BAA2B,eAAe,QAAQ,yHAAyH,0CAA0C,sCAAsC,cAAc,MAAM,sCAAsC,4CAA4C,mHAAmH,4CAA4C,yEAAyE,iBAAiB,yBAAyB,eAAe,oHAAoH,kKAAkK,wCAAwC,qEAAqE,sCAAsC,aAAa,4DAA4D,WAAW,SAAS,+CAA+C,mDAAmD,gDAAgD,+SAA+S,0GAA0G,oEAAoE,aAAa,oDAAoD,0GAA0G,SAAS,QAAQ,0CAA0C,gDAAgD,6CAA6C,0CAA0C,eAAe,aAAa,uCAAuC,WAAW,SAAS,iDAAiD,iDAAiD,oDAAoD,0GAA0G,SAAS,QAAQ,0CAA0C,gDAAgD,+CAA+C,+CAA+C,eAAe,aAAa,2CAA2C,WAAW,SAAS,mEAAmE,8BAA8B,8EAA8E,mCAAmC,8BAA8B,iJAAiJ,iCAAiC,gFAAgF,4CAA4C,iFAAiF,kEAAkE,2BAA2B,wBAAwB,sBAAsB,yBAAyB,6CAA6C,eAAe,0BAA0B,6CAA6C,eAAe,WAAW,sBAAsB,yBAAyB,8CAA8C,eAAe,0BAA0B,8CAA8C,eAAe,WAAW,iCAAiC,yBAAyB,yDAAyD,eAAe,0BAA0B,yDAAyD,eAAe,WAAW,YAAY,SAAS,uGAAuG,yCAAyC,8DAA8D,SAAS,sEAAsE,yIAAyI,+CAA+C,8BAA8B,mEAAmE,cAAc,yCAAyC,uDAAuD,YAAY,MAAM,2DAA2D,2DAA2D,sCAAsC,WAAW,8CAA8C,+BAA+B,2DAA2D,SAAS,qDAAqD,6IAA6I,sDAAsD,mDAAmD,sBAAsB,oCAAoC,mWAAmW,+DAA+D,kEAAkE,kCAAkC,0CAA0C,yHAAyH,0CAA0C,mDAAmD,6CAA6C,WAAW,0DAA0D,SAAS,gEAAgE,kDAAkD,8CAA8C,SAAS,QAAQ,wCAAwC,oDAAoD,qDAAqD,aAAa,WAAW,SAAS,2CAA2C,sZAAsZ,+CAA+C,4CAA4C,sDAAsD,mDAAmD,SAAS,+CAA+C,8XAA8X,kDAAkD,+CAA+C,mDAAmD,gDAAgD,SAAS,+HAA+H,sJAAsJ,8CAA8C,+BAA+B,qDAAqD,WAAW,+CAA+C,gDAAgD,iCAAiC,SAAS,uDAAuD,+XAA+X,uDAAuD,qDAAqD,uBAAuB,4CAA4C,6BAA6B,mEAAmE,mFAAmF,WAAW,SAAS,6CAA6C,wMAAwM,gDAAgD,8CAA8C,uDAAuD,qDAAqD,SAAS,iDAAiD,2MAA2M,mDAAmD,iDAAiD,oDAAoD,kDAAkD,SAAS,uHAAuH,+KAA+K,4CAA4C,gKAAgK,uDAAuD,wDAAwD,WAAW,6BAA6B,SAAS,gEAAgE,kPAAkP,wDAAwD,yDAAyD,yDAAyD,0DAA0D,SAAS,uUAAuU,8VAA8V,+CAA+C,sFAAsF,iDAAiD,oCAAoC,aAAa,4KAA4K,+IAA+I,WAAW,wGAAwG,oIAAoI,yDAAyD,6HAA6H,2BAA2B,SAAS,yFAAyF,oTAAoT,+CAA+C,mEAAmE,WAAW,sBAAsB,SAAS,0FAA0F,gKAAgK,mCAAmC,kCAAkC,2BAA2B,gBAAgB,QAAQ,iCAAiC,WAAW,2BAA2B,iBAAiB,QAAQ,uCAAuC,WAAW,sBAAsB,SAAS,iGAAiG,sCAAsC,wNAAwN,0DAA0D,gBAAgB,QAAQ,sCAAsC,wEAAwE,WAAW,mHAAmH,2BAA2B,iBAAiB,QAAQ,6CAA6C,WAAW,sBAAsB,SAAS,8EAA8E,4BAA4B,SAAS,kGAAkG,wKAAwK,+CAA+C,0OAA0O,yDAAyD,SAAS,QAAQ,gDAAgD,+CAA+C,mHAAmH,wCAAwC,4CAA4C,0DAA0D,uDAAuD,0BAA0B,8DAA8D,aAAa,6CAA6C,WAAW,SAAS,gHAAgH,iFAAiF,iDAAiD,oHAAoH,yCAAyC,+CAA+C,iDAAiD,aAAa,WAAW,gHAAgH,8CAA8C,oDAAoD,uDAAuD,2CAA2C,mDAAmD,aAAa,WAAW,SAAS,uGAAuG,iEAAiE,kCAAkC,6CAA6C,+CAA+C,WAAW,SAAS,QAAQ,EAAE,2FAA2F,0CAA0C,+EAA+E,+BAA+B,SAAS,2BAA2B,OAAO,6CAA6C,+FAA+F,QAAQ,oHAAoH,oCAAoC,8CAA8C,yCAAyC,OAAO,qGAAqG,wHAAwH,6DAA6D,4DAA4D,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,QAAQ,EAAE,wKAAwK,yCAAyC,sCAAsC,+BAA+B,2BAA2B,8CAA8C,OAAO,sEAAsE,gBAAgB,4BAA4B,mCAAmC,WAAW,SAAS,iBAAiB,4BAA4B,mCAAmC,WAAW,SAAS,QAAQ,EAAE,4DAA4D,gFAAgF,wEAAwE,sBAAsB,SAAS,sCAAsC,4EAA4E,sBAAsB,SAAS,sCAAsC,4EAA4E,sBAAsB,SAAS,sCAAsC,4EAA4E,sBAAsB,SAAS,mCAAmC,2EAA2E,SAAS,mCAAmC,+EAA+E,SAAS,mCAAmC,+EAA+E,SAAS,mCAAmC,+EAA+E,SAAS,0CAA0C,yDAAyD,2CAA2C,yCAAyC,sBAAsB,SAAS,8CAA8C,yDAAyD,2CAA2C,yCAAyC,yCAAyC,sBAAsB,SAAS,kDAAkD,yDAAyD,2CAA2C,yCAAyC,yCAAyC,yCAAyC,sBAAsB,SAAS,QAAQ,EAAE,6HAA6H,yCAAyC,2BAA2B,2BAA2B,mEAAmE,6BAA6B,2BAA2B,wBAAwB,+CAA+C,yBAAyB,OAAO,0EAA0E,iCAAiC,gDAAgD,SAAS,QAAQ,EAAE,mDAAmD,wEAAwE,yCAAyC,2FAA2F,WAAW,4EAA4E,2BAA2B,SAAS,yCAAyC,+BAA+B,sBAAsB,SAAS,oCAAoC,oEAAoE,kCAAkC,oCAAoC,sCAAsC,sBAAsB,SAAS,yDAAyD,gCAAgC,mCAAmC,4CAA4C,OAAO,QAAQ,qEAAqE,WAAW,sBAAsB,SAAS,0CAA0C,iDAAiD,0CAA0C,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,0CAA0C,2CAA2C,sBAAsB,SAAS,QAAQ,EAAE,wJAAwJ,sDAAsD,sDAAsD,OAAO,2GAA2G,8HAA8H,gEAAgE,0DAA0D,sBAAsB,SAAS,QAAQ,EAAE,wJAAwJ,sDAAsD,sDAAsD,OAAO,uGAAuG,0HAA0H,8DAA8D,0DAA0D,sBAAsB,SAAS,QAAQ,EAAE,kNAAkN,gDAAgD,iHAAiH,iCAAiC,uBAAuB,gBAAgB,iBAAiB,gBAAgB,mBAAmB,cAAc,mBAAmB,QAAQ,+CAA+C,qBAAqB,4BAA4B,sGAAsG,+BAA+B,aAAa,SAAS,QAAQ,EAAE,OAAO,gCAAgC,uCAAuC,OAAO,4EAA4E,+CAA+C,gDAAgD,mCAAmC,yCAAyC,gDAAgD,OAAO,QAAQ,0EAA0E,WAAW,SAAS,OAAO,2CAA2C,sEAAsE,mIAAmI,SAAS,qDAAqD,2DAA2D,wEAAwE,mHAAmH,YAAY,uDAAuD,wIAAwI,uHAAuH,YAAY,MAAM,yEAAyE,WAAW,SAAS,0DAA0D,8BAA8B,iEAAiE,qCAAqC,4BAA4B,SAAS,4DAA4D,8BAA8B,qDAAqD,yFAAyF,4BAA4B,WAAW,+CAA+C,OAAO,QAAQ,yEAAyE,WAAW,qCAAqC,4BAA4B,SAAS,QAAQ,EAAE,sGAAsG,wEAAwE,2BAA2B,uBAAuB,2BAA2B,6BAA6B,OAAO,uCAAuC,4BAA4B,8FAA8F,qDAAqD,6BAA6B,4BAA4B,SAAS,4BAA4B,gCAAgC,6BAA6B,+BAA+B,SAAS,sCAAsC,0BAA0B,gCAAgC,SAAS,gCAAgC,uBAAuB,mDAAmD,yBAAyB,mBAAmB,WAAW,+BAA+B,4FAA4F,qDAAqD,iCAAiC,qCAAqC,WAAW,sBAAsB,SAAS,QAAQ,EAAE,2VAA2V,8DAA8D,kDAAkD,gGAAgG,uDAAuD,OAAO,2CAA2C,8CAA8C,+BAA+B,uBAAuB,2BAA2B,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,mCAAmC,qCAAqC,6BAA6B,iCAAiC,sBAAsB,SAAS,iFAAiF,6BAA6B,wEAAwE,sBAAsB,SAAS,4CAA4C,sCAAsC,oCAAoC,2BAA2B,uBAAuB,YAAY,MAAM,uDAAuD,gHAAgH,yBAAyB,sBAAsB,SAAS,QAAQ,EAAE,sMAAsM,+DAA+D,+GAA+G,mIAAmI,iDAAiD,OAAO,6CAA6C,4CAA4C,+BAA+B,2BAA2B,mBAAmB,sBAAsB,SAAS,6BAA6B,qDAAqD,SAAS,mCAAmC,qCAAqC,iCAAiC,yBAAyB,sBAAsB,SAAS,4CAA4C,uEAAuE,kDAAkD,wBAAwB,sBAAsB,SAAS,QAAQ,EAAE,qHAAqH,8BAA8B,iCAAiC,yDAAyD,OAAO,4EAA4E,wEAAwE,qEAAqE,wLAAwL,6BAA6B,sDAAsD,2DAA2D,gEAAgE,mCAAmC,+CAA+C,sDAAsD,kDAAkD,UAAU,yDAAyD,yDAAyD,SAAS,sDAAsD,0EAA0E,uDAAuD,oEAAoE,iCAAiC,IAAI,gDAAgD,sBAAsB,OAAO,8EAA8E,oEAAoE,4DAA4D,+BAA+B,6BAA6B,uCAAuC,kCAAkC,uCAAuC,gDAAgD,kEAAkE,oDAAoD,2DAA2D,6DAA6D,wDAAwD,gDAAgD,0CAA0C,wBAAwB,+CAA+C,OAAO,QAAQ,oCAAoC,+DAA+D,QAAQ,QAAQ,2DAA2D,qDAAqD,8DAA8D,iHAAiH,yDAAyD,8BAA8B,yDAAyD,8BAA8B,eAAe,aAAa,YAAY,yDAAyD,yDAAyD,wDAAwD,wBAAwB,kIAAkI,QAAQ,QAAQ,yGAAyG,gFAAgF,gGAAgG,uDAAuD,4BAA4B,uDAAuD,4BAA4B,aAAa,WAAW,sCAAsC,UAAU,OAAO,KAAK,uNAAuN,8BAA8B,2BAA2B,qCAAqC,wCAAwC,oCAAoC,2BAA2B,4CAA4C,0KAA0K,wCAAwC,OAAO,cAAc,2CAA2C,yCAAyC,0HAA0H,SAAS,wFAAwF,gDAAgD,aAAa,EAAE,2DAA2D,4BAA4B,sBAAsB,OAAO,sEAAsE,4DAA4D,uDAAuD,qCAAqC,mCAAmC,QAAQ,sDAAsD,mCAAmC,kCAAkC,kCAAkC,yCAAyC,4EAA4E,kEAAkE,kEAAkE,iEAAiE,uEAAuE,oDAAoD,2CAA2C,uDAAuD,YAAY,MAAM,8DAA8D,WAAW,UAAU,OAAO,GAAG,6SAA6S,0BAA0B,wCAAwC,kCAAkC,SAAS,yBAAyB,4BAA4B,QAAQ,+EAA+E,SAAS,wBAAwB,OAAO,yCAAyC,0CAA0C,4CAA4C,0BAA0B,sBAAsB,0CAA0C,wCAAwC,yBAAyB,kBAAkB,QAAQ,gCAAgC,oDAAoD,qCAAqC,mCAAmC,sDAAsD,sDAAsD,WAAW,SAAS,uFAAuF,gFAAgF,gDAAgD,qFAAqF,EAAE,sDAAsD,2BAA2B,yBAAyB,yCAAyC,oCAAoC,OAAO,yEAAyE,0DAA0D,gEAAgE,mCAAmC,uCAAuC,yCAAyC,oDAAoD,iCAAiC,uCAAuC,2DAA2D,6DAA6D,kCAAkC,kBAAkB,QAAQ,kCAAkC,sDAAsD,8EAA8E,uDAAuD,+DAA+D,qFAAqF,uDAAuD,mEAAmE,qBAAqB,aAAa,WAAW,iEAAiE,mEAAmE,UAAU,OAAO,GAAG,0KAA0K,2BAA2B,qCAAqC,2BAA2B,oEAAoE,8CAA8C,8BAA8B,EAAE,8CAA8C,6CAA6C,oCAAoC,sBAAsB,+EAA+E,4DAA4D,gFAAgF,EAAE,wEAAwE,gFAAgF,+BAA+B,0BAA0B,6CAA6C,UAAU,MAAM,kDAAkD,SAAS,uCAAuC,eAAe,mEAAmE,8DAA8D,wDAAwD,gCAAgC,8BAA8B,QAAQ,uDAAuD,yCAAyC,gDAAgD,UAAU,MAAM,uDAAuD,SAAS,4CAA4C,0BAA0B,6CAA6C,UAAU,MAAM,4CAA4C,gDAAgD,SAAS,gBAAgB,wOAAwO,8BAA8B,2BAA2B,qCAAqC,wCAAwC,oCAAoC,2BAA2B,gDAAgD,aAAa,EAAE,4CAA4C,iGAAiG,mDAAmD,4BAA4B,wBAAwB,OAAO,0EAA0E,oEAAoE,2DAA2D,8CAA8C,4CAA4C,QAAQ,0DAA0D,yFAAyF,uCAAuC,8DAA8D,iCAAiC,mDAAmD,mBAAmB,eAAe,uBAAuB,iBAAiB,eAAe,yBAAyB,iBAAiB,eAAe,yBAAyB,oBAAoB,gBAAgB,wBAAwB,oBAAoB,gBAAgB,oCAAoC,yCAAyC,qDAAqD,UAAU,MAAM,4DAA4D,SAAS,QAAQ,4NAA4N,8BAA8B,2BAA2B,qCAAqC,wCAAwC,oCAAoC,2BAA2B,4DAA4D,wCAAwC,iDAAiD,8BAA8B,EAAE,gFAAgF,2DAA2D,0DAA0D,2EAA2E,wDAAwD,sBAAsB,OAAO,4EAA4E,wEAAwE,6DAA6D,8CAA8C,4CAA4C,QAAQ,4DAA4D,mCAAmC,iCAAiC,+BAA+B,kCAAkC,wCAAwC,2CAA2C,kDAAkD,YAAY,MAAM,+DAA+D,4CAA4C,gDAAgD,+CAA+C,OAAO,QAAQ,8DAA8D,4DAA4D,aAAa,sCAAsC,WAAW,yFAAyF,UAAU,OAAO,GAAG,wHAAwH,0BAA0B,kCAAkC,qEAAqE,qEAAqE,mCAAmC,kCAAkC,8BAA8B,uCAAuC,gDAAgD,gBAAgB,mBAAmB,4DAA4D,0DAA0D,qDAAqD,sCAAsC,OAAO,oCAAoC,OAAO,oCAAoC,OAAO,oCAAoC,OAAO,SAAS,4CAA4C,qFAAqF,gFAAgF,gDAAgD,6BAA6B,EAAE,sDAAsD,OAAO,qEAAqE,kDAAkD,yPAAyP,8BAA8B,8BAA8B,6BAA6B,kCAAkC,qEAAqE,qEAAqE,0BAA0B,sBAAsB,iBAAiB,4BAA4B,kDAAkD,cAAc,QAAQ,gDAAgD,qCAAqC,mCAAmC,mCAAmC,iCAAiC,8CAA8C,mDAAmD,iDAAiD,SAAS,kDAAkD,cAAc,QAAQ,8CAA8C,gDAAgD,uBAAuB,eAAe,QAAQ,+EAA+E,kCAAkC,gCAAgC,qCAAqC,mDAAmD,wFAAwF,kCAAkC,gCAAgC,qCAAqC,mDAAmD,WAAW,SAAS,4CAA4C,qFAAqF,gFAAgF,gDAAgD,6BAA6B,EAAE,sDAAsD,OAAO,0EAA0E,4DAA4D,sLAAsL,sFAAsF,sDAAsD,2DAA2D,gEAAgE,mCAAmC,+CAA+C,sDAAsD,8CAA8C,UAAU,MAAM,+HAA+H,SAAS,sDAAsD,0EAA0E,uDAAuD,oEAAoE,iCAAiC,IAAI,gDAAgD,oBAAoB,OAAO,4EAA4E,gEAAgE,0DAA0D,+BAA+B,6BAA6B,uCAAuC,kCAAkC,gDAAgD,kEAAkE,oDAAoD,2DAA2D,6DAA6D,8CAA8C,wCAAwC,sBAAsB,6CAA6C,OAAO,QAAQ,kCAAkC,qCAAqC,4LAA4L,6GAA6G,qDAAqD,0BAA0B,qDAAqD,0BAA0B,WAAW,sCAAsC,UAAU,OAAO,KAAK,oOAAoO,8BAA8B,2BAA2B,qCAAqC,wCAAwC,oCAAoC,2BAA2B,2CAA2C,4CAA4C,4MAA4M,gDAAgD,aAAa,EAAE,yDAAyD,kCAAkC,wCAAwC,iGAAiG,yDAAyD,kCAAkC,sBAAsB,OAAO,6EAA6E,0EAA0E,8DAA8D,2CAA2C,yCAAyC,yCAAyC,yCAAyC,QAAQ,6DAA6D,+BAA+B,6BAA6B,6BAA6B,kCAAkC,6DAA6D,kEAAkE,gCAAgC,uCAAuC,2CAA2C,6DAA6D,2DAA2D,YAAY,MAAM,oEAAoE,kEAAkE,WAAW,uCAAuC,8CAA8C,UAAU,OAAO,GAAG,2YAA2Y,4CAA4C,8CAA8C,4CAA4C,EAAE,0BAA0B,sBAAsB,0BAA0B,kEAAkE,4CAA4C,0CAA0C,8CAA8C,6CAA6C,2DAA2D,0CAA0C,0CAA0C,0CAA0C,0DAA0D,0CAA0C,0CAA0C,0CAA0C,4DAA4D,0CAA0C,0CAA0C,0CAA0C,uDAAuD,sCAAsC,sCAAsC,sCAAsC,oDAAoD,qCAAqC,qCAAqC,0DAA0D,sCAAsC,4DAA4D,0CAA0C,4CAA4C,0CAA0C,yCAAyC,+BAA+B,6BAA6B,SAAS,wCAAwC,mCAAmC,iDAAiD,+CAA+C,gCAAgC,WAAW,6DAA6D,SAAS,uFAAuF,gFAAgF,sDAAsD,6BAA6B,qFAAqF,yCAAyC,oCAAoC,iCAAiC,sBAAsB,OAAO,uEAAuE,sDAAsD,mDAAmD,+BAA+B,mCAAmC,gCAAgC,6CAA6C,oDAAoD,yCAAyC,uCAAuC,+DAA+D,gDAAgD,OAAO,QAAQ,2EAA2E,aAAa,WAAW,SAAS,kCAAkC,mCAAmC,iCAAiC,2BAA2B,iKAAiK,iEAAiE,iCAAiC,2DAA2D,sCAAsC,sCAAsC,oCAAoC,wDAAwD,oCAAoC,oCAAoC,kCAAkC,iEAAiE,kDAAkD,wCAAwC,yDAAyD,mCAAmC,qCAAqC,mCAAmC,yCAAyC,qCAAqC,uCAAuC,qCAAqC,iEAAiE,UAAU,OAAO,GAAG,uJAAuJ,6BAA6B,oDAAoD,oHAAoH,gDAAgD,4CAA4C,6DAA6D,+EAA+E,oEAAoE,eAAe,IAAI,sCAAsC,sBAAsB,OAAO,oEAAoE,gDAAgD,kDAAkD,6BAA6B,0CAA0C,uCAAuC,kFAAkF,WAAW,4CAA4C,6CAA6C,WAAW,sCAAsC,4BAA4B,0BAA0B,kYAAkY,mCAAmC,8BAA8B,oBAAoB,mBAAmB,4BAA4B,oBAAoB,mBAAmB,4BAA4B,oBAAoB,mBAAmB,4BAA4B,qBAAqB,oBAAoB,6BAA6B,qBAAqB,oBAAoB,6BAA6B,qBAAqB,oBAAoB,6BAA6B,qBAAqB,oBAAoB,6BAA6B,qBAAqB,oBAAoB,sCAAsC,gDAAgD,UAAU,QAAQ,IAAI,+DAA+D,6BAA6B,oBAAoB,oBAAoB,QAAQ,iHAAiH,iCAAiC,uBAAuB,2DAA2D,oHAAoH,2HAA2H,4CAA4C,+DAA+D,wFAAwF,oEAAoE,eAAe,IAAI,8CAA8C,OAAO,qEAAqE,kDAAkD,mEAAmE,2BAA2B,oCAAoC,uCAAuC,kCAAkC,yCAAyC,iEAAiE,QAAQ,0HAA0H,kCAAkC,2BAA2B,sDAAsD,2DAA2D,qIAAqI,4CAA4C,sFAAsF,uCAAuC,4DAA4D,eAAe,IAAI,wGAAwG,6CAA6C,wFAAwF,wCAAwC,gEAAgE,mEAAmE,MAAM,OAAO,8DAA8D,oDAAoD,oEAAoE,0CAA0C,sDAAsD,yFAAyF,yCAAyC,iEAAiE,QAAQ,iaAAia,qBAAqB,iFAAiF,wEAAwE,oDAAoD,6CAA6C,gEAAgE,kEAAkE,2CAA2C,8CAA8C,uGAAuG,uEAAuE,8CAA8C,SAAS,qCAAqC,qEAAqE,eAAe,IAAI,yCAAyC,4BAA4B,qEAAqE,eAAe,IAAI,yCAAyC,4BAA4B,iCAAiC,sDAAsD,OAAO,kEAAkE,oDAAoD,0DAA0D,iCAAiC,kBAAkB,6CAA6C,8EAA8E,8CAA8C,YAAY,+BAA+B,8CAA8C,YAAY,MAAM,sDAAsD,yCAAyC,8DAA8D,WAAW,UAAU,OAAO,KAAK,oFAAoF,kEAAkE,kEAAkE,wEAAwE,+BAA+B,gEAAgE,oCAAoC,+BAA+B,QAAQ,2DAA2D,+CAA+C,6CAA6C,QAAQ,+IAA+I,yBAAyB,sHAAsH,iHAAiH,4CAA4C,qFAAqF,gFAAgF,gDAAgD,6BAA6B,EAAE,sDAAsD,OAAO,qEAAqE,kDAAkD,2FAA2F,qEAAqE,kCAAkC,iDAAiD,OAAO,QAAQ,8DAA8D,WAAW,uBAAuB,SAAS,oDAAoD,kDAAkD,+BAA+B,2BAA2B,SAAS,oDAAoD,8EAA8E,gCAAgC,4BAA4B,SAAS,QAAQ,4HAA4H,+FAA+F,gEAAgE,OAAO,wBAAwB,yBAAyB,8CAA8C,yFAAyF,uBAAuB,OAAO,2CAA2C,sDAAsD,sFAAsF,uCAAuC,sCAAsC,qCAAqC,mCAAmC,UAAU,uBAAuB,OAAO,iDAAiD,6EAA6E,8CAA8C,OAAO,qCAAqC,2EAA2E,oCAAoC,OAAO,qDAAqD,iFAAiF,8CAA8C,OAAO,iDAAiD,6FAA6F,8CAA8C,OAAO,oDAAoD,gGAAgG,8CAA8C,OAAO,qDAAqD,iGAAiG,8CAA8C,OAAO,kCAAkC,oFAAoF,oCAAoC,OAAO,kEAAkE,qIAAqI,uEAAuE,OAAO,iDAAiD,6GAA6G,wDAAwD,OAAO,kDAAkD,+GAA+G,yDAAyD,OAAO,yDAAyD,6HAA6H,gEAAgE,OAAO,kDAAkD,+GAA+G,yDAAyD,OAAO,mDAAmD,iHAAiH,0DAA0D,OAAO,kDAAkD,+GAA+G,yDAAyD,OAAO,mDAAmD,iHAAiH,0DAA0D,OAAO,oDAAoD,mHAAmH,2DAA2D,OAAO,oDAAoD,mHAAmH,2DAA2D,OAAO,+DAA+D,kEAAkE,+DAA+D,kDAAkD,8CAA8C,yBAAyB,QAAQ,mDAAmD,sDAAsD,iJAAiJ,4HAA4H,0CAA0C,SAAS,6DAA6D,uJAAuJ,6HAA6H,0CAA0C,SAAS,8CAA8C,2IAA2I,wCAAwC,8CAA8C,OAAO,QAAQ,oCAAoC,kFAAkF,WAAW,0BAA0B,SAAS,QAAQ,EAAE,8CAA8C,yCAAyC,4FAA4F,qCAAqC,SAAS,QAAQ,EAAE,qDAAqD,4GAA4G,8CAA8C,+BAA+B,yBAAyB,OAAO,iFAAiF,+CAA+C,sGAAsG,8CAA8C,+BAA+B,OAAO,2EAA2E,yCAAyC,6FAA6F,8CAA8C,+BAA+B,OAAO,qEAAqE,wCAAwC,6CAA6C,8EAA8E,SAAS,iEAAiE,sFAAsF,SAAS,kEAAkE,yFAAyF,SAAS,QAAQ,EAAE,2CAA2C,iFAAiF,oCAAoC,OAAO,mDAAmD,2GAA2G,4CAA4C,OAAO,2CAA2C,+FAA+F,8FAA8F,4CAA4C,IAAI,OAAO,oDAAoD,oHAAoH,QAAQ,qDAAqD,wFAAwF,QAAQ,+CAA+C,uGAAuG,kGAAkG,4CAA4C,IAAI,OAAO,gDAAgD,0CAA0C,iIAAiI,iDAAiD,SAAS,QAAQ,EAAE,qCAAqC,gFAAgF,uCAAuC,OAAO,+CAA+C,iGAAiG,8CAA8C,OAAO,8CAA8C,6CAA6C,oFAAoF,gDAAgD,SAAS,2BAA2B,iFAAiF,8BAA8B,SAAS,4CAA4C,mGAAmG,yCAAyC,SAAS,0CAA0C,gFAAgF,8CAA8C,SAAS,MAAM,EAAE,sCAAsC,6CAA6C,oFAAoF,gDAAgD,SAAS,2BAA2B,iFAAiF,8BAA8B,SAAS,4CAA4C,mGAAmG,yCAAyC,SAAS,kDAAkD,yGAAyG,+CAA+C,SAAS,0CAA0C,gFAAgF,8CAA8C,SAAS,MAAM,EAAE,4DAA4D,mFAAmF,8CAA8C,QAAQ,6BAA6B,+BAA+B,oGAAoG,6BAA6B,SAAS,gDAAgD,qGAAqG,8CAA8C,SAAS,6CAA6C,iGAAiG,6CAA6C,SAAS,QAAQ,EAAE,yCAAyC,0DAA0D,kHAAkH,6CAA6C,SAAS,6CAA6C,2HAA2H,2CAA2C,SAAS,mDAAmD,sFAAsF,SAAS,iEAAiE,sIAAsI,qDAAqD,SAAS,sEAAsE,qFAAqF,SAAS,QAAQ,EAAE,yCAAyC,yCAAyC,mGAAmG,sCAAsC,SAAS,yDAAyD,kHAAkH,6CAA6C,SAAS,iCAAiC,iBAAiB,yCAAyC,uDAAuD,iIAAiI,mDAAmD,YAAY,SAAS,oDAAoD,2HAA2H,oDAAoD,SAAS,qCAAqC,gFAAgF,SAAS,6CAA6C,2HAA2H,2CAA2C,SAAS,6CAA6C,2HAA2H,2CAA2C,SAAS,mDAAmD,sFAAsF,SAAS,mCAAmC,6HAA6H,qCAAqC,SAAS,yCAAyC,uHAAuH,2CAA2C,SAAS,+BAA+B,2EAA2E,SAAS,6BAA6B,yEAAyE,SAAS,6BAA6B,yEAAyE,SAAS,6BAA6B,yEAAyE,SAAS,kCAAkC,8EAA8E,SAAS,iEAAiE,sIAAsI,qDAAqD,SAAS,sEAAsE,qFAAqF,SAAS,sEAAsE,iJAAiJ,2EAA2E,SAAS,QAAQ,EAAE,8DAA8D,oGAAoG,yCAAyC,QAAQ,kEAAkE,0IAA0I,4CAA4C,QAAQ,qCAAqC,6CAA6C,kGAAkG,yCAAyC,SAAS,gDAAgD,sGAAsG,6CAA6C,SAAS,kDAAkD,wGAAwG,+CAA+C,SAAS,QAAQ,EAAE,uCAAuC,kDAAkD,6GAA6G,+CAA+C,SAAS,sCAAsC,qGAAqG,oDAAoD,SAAS,2CAA2C,wGAAwG,kDAAkD,SAAS,QAAQ,EAAE,yCAAyC,8DAA8D,wGAAwG,oEAAoE,SAAS,4CAA4C,8GAA8G,6CAA6C,SAAS,qCAAqC,sGAAsG,sCAAsC,SAAS,QAAQ,EAAE,yCAAyC,iDAAiD,uIAAuI,SAAS,4CAA4C,+HAA+H,SAAS,8CAA8C,kHAAkH,+CAA+C,SAAS,2CAA2C,4GAA4G,4CAA4C,SAAS,wDAAwD,8GAA8G,yDAAyD,SAAS,wCAAwC,gHAAgH,sCAAsC,SAAS,6DAA6D,wGAAwG,oEAAoE,SAAS,4CAA4C,8GAA8G,6CAA6C,SAAS,qCAAqC,sGAAsG,sCAAsC,SAAS,QAAQ,EAAE,yCAAyC,8DAA8D,wGAAwG,oEAAoE,SAAS,qCAAqC,sGAAsG,sCAAsC,SAAS,QAAQ,EAAE,gEAAgE,+EAA+E,QAAQ,0CAA0C,2CAA2C,sGAAsG,4CAA4C,SAAS,iCAAiC,sGAAsG,SAAS,+CAA+C,2HAA2H,sDAAsD,SAAS,QAAQ,EAAE,oDAAoD,qBAAqB,0BAA0B,kFAAkF,qCAAqC,WAAW,kCAAkC,kFAAkF,sCAAsC,WAAW,OAAO,uBAAuB,0BAA0B,4HAA4H,WAAW,2BAA2B,4HAA4H,WAAW,OAAO,QAAQ,EAAE,+CAA+C,kBAAkB,0BAA0B,+EAA+E,6BAA6B,WAAW,OAAO,QAAQ,EAAE,sEAAsE,0BAA0B,+EAA+E,SAAS,yBAAyB,+EAA+E,SAAS,QAAQ,EAAE,uEAAuE,0BAA0B,2FAA2F,uCAAuC,SAAS,gCAAgC,2FAA2F,wCAAwC,SAAS,QAAQ,EAAE,yFAAyF,wJAAwJ,kEAAkE,yCAAyC,QAAQ,yDAAyD,mBAAmB,0BAA0B,yEAAyE,WAAW,OAAO,yBAAyB,iCAAiC,uFAAuF,yCAAyC,WAAW,OAAO,0BAA0B,iCAAiC,yFAAyF,0CAA0C,WAAW,OAAO,2BAA2B,iCAAiC,2FAA2F,2CAA2C,WAAW,OAAO,yBAAyB,iCAAiC,uFAAuF,yCAAyC,WAAW,OAAO,4BAA4B,iCAAiC,6FAA6F,4CAA4C,WAAW,OAAO,0BAA0B,iCAAiC,yFAAyF,0CAA0C,WAAW,OAAO,yBAAyB,iCAAiC,uFAAuF,yCAAyC,WAAW,OAAO,6BAA6B,0BAA0B,6IAA6I,WAAW,OAAO,oBAAoB,iCAAiC,4EAA4E,mCAAmC,WAAW,OAAO,wBAAwB,0BAA0B,6EAA6E,WAAW,OAAO,wBAAwB,iCAAiC,yFAAyF,4CAA4C,WAAW,OAAO,yBAAyB,iCAAiC,2FAA2F,6CAA6C,WAAW,OAAO,MAAM,EAAE,mEAAmE,iBAAiB,0BAA0B,sGAAsG,mCAAmC,WAAW,OAAO,QAAQ,EAAE,gDAAgD,sCAAsC,+FAA+F,+BAA+B,SAAS,4DAA4D,4CAA4C,mGAAmG,WAAW,mFAAmF,sCAAsC,SAAS,oCAAoC,2FAA2F,2BAA2B,SAAS,qCAAqC,uFAAuF,SAAS,oCAAoC,sFAAsF,SAAS,QAAQ,EAAE,0DAA0D,oBAAoB,0BAA0B,6FAA6F,6BAA6B,WAAW,OAAO,iBAAiB,0BAA0B,0FAA0F,6BAA6B,WAAW,OAAO,QAAQ,EAAE,2DAA2D,kBAAkB,0BAA0B,6GAA6G,WAAW,OAAO,kBAAkB,4BAA4B,gHAAgH,sBAAsB,WAAW,OAAO,QAAQ,EAAE,4DAA4D,qBAAqB,0BAA0B,4EAA4E,WAAW,2BAA2B,4EAA4E,WAAW,OAAO,iBAAiB,0BAA0B,yEAAyE,6BAA6B,WAAW,OAAO,mBAAmB,0BAA0B,yHAAyH,WAAW,kCAAkC,wHAAwH,uDAAuD,WAAW,OAAO,QAAQ,EAAE,6DAA6D,gBAAgB,0BAA0B,wHAAwH,uBAAuB,WAAW,2BAA2B,uHAAuH,WAAW,OAAO,QAAQ,EAAE,0DAA0D,sBAAsB,0BAA0B,4GAA4G,6CAA6C,WAAW,kCAAkC,6GAA6G,8CAA8C,WAAW,OAAO,QAAQ,EAAE,uDAAuD,6CAA6C,sGAAsG,sCAAsC,SAAS,wCAAwC,8GAA8G,oDAAoD,SAAS,oCAAoC,iGAAiG,2CAA2C,SAAS,oCAAoC,wFAAwF,kCAAkC,SAAS,6CAA6C,6HAA6H,0DAA0D,SAAS,+CAA+C,sIAAsI,+DAA+D,SAAS,iDAAiD,0IAA0I,iEAAiE,SAAS,mDAAmD,iJAAiJ,sEAAsE,SAAS,oDAAoD,mJAAmJ,uEAAuE,SAAS,yCAAyC,0HAA0H,yDAAyD,SAAS,4CAA4C,gHAAgH,gDAAgD,SAAS,6CAA6C,oIAAoI,+DAA+D,SAAS,gDAAgD,gGAAgG,uCAAuC,SAAS,kCAAkC,mFAAmF,SAAS,kCAAkC,mFAAmF,SAAS,mCAAmC,oFAAoF,SAAS,qCAAqC,sFAAsF,SAAS,QAAQ,EAAE,yDAAyD,2BAA2B,0BAA0B,0CAA0C,WAAW,kCAAkC,gGAAgG,yCAAyC,WAAW,OAAO,uBAAuB,0BAA0B,uCAAuC,WAAW,kCAAkC,0FAA0F,sCAAsC,WAAW,OAAO,2BAA2B,0BAA0B,2CAA2C,WAAW,kCAAkC,kGAAkG,0CAA0C,WAAW,OAAO,MAAM,EAAE,0DAA0D,mBAAmB,0BAA0B,0EAA0E,WAAW,qCAAqC,sDAAsD,sIAAsI,0CAA0C,WAAW,OAAO,QAAQ,EAAE,qEAAqE,gBAAgB,0BAA0B,qFAAqF,oCAAoC,WAAW,kCAAkC,qFAAqF,qCAAqC,WAAW,OAAO,eAAe,0BAA0B,qFAAqF,oCAAoC,WAAW,kCAAkC,qFAAqF,qCAAqC,WAAW,OAAO,mBAAmB,0BAA0B,6FAA6F,wCAAwC,WAAW,kCAAkC,6FAA6F,yCAAyC,WAAW,OAAO,mBAAmB,0BAA0B,6FAA6F,wCAAwC,WAAW,kCAAkC,6FAA6F,yCAAyC,WAAW,OAAO,oBAAoB,0BAA0B,+FAA+F,yCAAyC,WAAW,kCAAkC,+FAA+F,0CAA0C,WAAW,OAAO,gBAAgB,0BAA0B,uFAAuF,qCAAqC,WAAW,kCAAkC,uFAAuF,sCAAsC,WAAW,OAAO,gBAAgB,0BAA0B,uFAAuF,qCAAqC,WAAW,kCAAkC,uFAAuF,sCAAsC,WAAW,OAAO,gBAAgB,0BAA0B,uFAAuF,qCAAqC,WAAW,kCAAkC,uFAAuF,sCAAsC,WAAW,OAAO,cAAc,0BAA0B,mFAAmF,mCAAmC,WAAW,kCAAkC,mFAAmF,oCAAoC,WAAW,OAAO,yBAAyB,0BAA0B,yGAAyG,8CAA8C,WAAW,kCAAkC,yGAAyG,+CAA+C,WAAW,OAAO,QAAQ,EAAE,sDAAsD,wCAAwC,uFAAuF,SAAS,QAAQ,EAAE,wDAAwD,mBAAmB,uCAAuC,8EAA8E,WAAW,OAAO,QAAQ,EAAE,wDAAwD,iGAAiG,uBAAuB,0CAA0C,mDAAmD,oCAAoC,UAAU,EAAE,kBAAkB,QAAQ,qDAAqD,sFAAsF,qCAAqC,QAAQ,iFAAiF,+EAA+E,4CAA4C,QAAQ,mCAAmC,uEAAuE,4JAA4J,mBAAmB,mCAAmC,mEAAmE,sCAAsC,yCAAyC,WAAW,oEAAoE,SAAS,wCAAwC,sHAAsH,iCAAiC,SAAS,QAAQ,wBAAwB,gGAAgG,iHAAiH,2CAA2C,kDAAkD,uEAAuE,mDAAmD,yBAAyB,SAAS,uEAAuE,yHAAyH,+CAA+C,kDAAkD,wEAAwE,mDAAmD,yBAAyB,SAAS,6CAA6C,mHAAmH,SAAS,iDAAiD,uHAAuH,SAAS,QAAQ,oCAAoC,kGAAkG,0DAA0D,uFAAuF,iCAAiC,UAAU,4DAA4D,2FAA2F,mCAAmC,UAAU,uCAAuC,8FAA8F,UAAU,OAAO,yCAAyC,2GAA2G,+FAA+F,kCAAkC,mCAAmC,0CAA0C,oCAAoC,OAAO,4DAA4D,kDAAkD,0CAA0C,kCAAkC,sCAAsC,0CAA0C,sCAAsC,8BAA8B,sBAAsB,0BAA0B,kCAAkC,4BAA4B,sBAAsB,sCAAsC,gCAAgC,wBAAwB,wBAAwB,wCAAwC,gCAAgC,wBAAwB,4BAA4B,0BAA0B,wCAAwC,sCAAsC,kDAAkD,sCAAsC,0CAA0C,wCAAwC,8BAA8B,8DAA8D,kDAAkD,kDAAkD,0CAA0C,wCAAwC,4CAA4C,wDAAwD,0DAA0D,4CAA4C,oCAAoC,sCAAsC,kDAAkD,oCAAoC,oCAAoC,4BAA4B,sCAAsC,0BAA0B,sCAAsC,8CAA8C,kCAAkC,oCAAoC,0CAA0C,8CAA8C,4DAA4D,gDAAgD,wCAAwC,sCAAsC,0BAA0B,wCAAwC,kDAAkD,oDAAoD,oCAAoC,sCAAsC,4BAA4B,0CAA0C,8CAA8C,wCAAwC,0CAA0C,0BAA0B,sDAAsD,sDAAsD,8DAA8D,sDAAsD,oDAAoD,wDAAwD,0CAA0C,8CAA8C,0CAA0C,4CAA4C,wDAAwD,4CAA4C,0CAA0C,8BAA8B,8DAA8D,4CAA4C,gCAAgC,oEAAoE,oEAAoE,kDAAkD,gEAAgE,0BAA0B,gCAAgC,kCAAkC,4BAA4B,8CAA8C,0BAA0B,sEAAsE,kDAAkD,sDAAsD,gDAAgD,sCAAsC,gCAAgC,yBAAyB,kCAAkC,sCAAsC,0BAA0B,8BAA8B,4BAA4B,sBAAsB,8BAA8B,8BAA8B,wBAAwB,wBAAwB,0BAA0B,0BAA0B,8BAA8B,8BAA8B,8BAA8B,oCAAoC,0BAA0B,0DAA0D,sDAAsD,8CAA8C,4CAA4C,gDAAgD,sDAAsD,0DAA0D,oCAAoC,8CAA8C,kDAAkD,4DAA4D,wCAAwC,kCAAkC,oCAAoC,sCAAsC,sCAAsC,oCAAoC,0BAA0B,wBAAwB,kCAAkC,wBAAwB,kCAAkC,0BAA0B,oCAAoC,oCAAoC,oCAAoC,kDAAkD,oDAAoD,gEAAgE,sDAAsD,kEAAkE,oDAAoD,gEAAgE,sDAAsD,kEAAkE,wDAAwD,oEAAoE,oDAAoD,gEAAgE,wCAAwC,oDAAoD,kDAAkD,8DAA8D,0CAA0C,sDAAsD,wCAAwC,oDAAoD,4CAA4C,wDAAwD,wCAAwC,oDAAoD,0CAA0C,sDAAsD,0CAA0C,sDAAsD,0CAA0C,sDAAsD,8CAA8C,0DAA0D,0CAA0C,wCAAwC,oDAAoD,gDAAgD,4DAA4D,4CAA4C,wDAAwD,sCAAsC,kDAAkD,4CAA4C,4CAA4C,kDAAkD,4CAA4C,4CAA4C,wDAAwD,wDAAwD,kDAAkD,gDAAgD,oDAAoD,sDAAsD,kDAAkD,wDAAwD,kDAAkD,oDAAoD,kDAAkD,gCAAgC,4DAA4D,4DAA4D,0DAA0D,wDAAwD,0DAA0D,wDAAwD,sEAAsE,wDAAwD,sDAAsD,8CAA8C,gCAAgC,gDAAgD,gDAAgD,kDAAkD,wCAAwC,kCAAkC,oCAAoC,wDAAwD,0DAA0D,sCAAsC,gCAAgC,0BAA0B,wCAAwC,wCAAwC,0CAA0C,kDAAkD,wDAAwD,0DAA0D,4CAA4C,wCAAwC,gDAAgD,kCAAkC,gCAAgC,oCAAoC,sCAAsC,0CAA0C,gCAAgC,oCAAoC,wCAAwC,oCAAoC,4CAA4C,gDAAgD,sDAAsD,gDAAgD,4CAA4C,sCAAsC,gDAAgD,8DAA8D,sCAAsC,sCAAsC,oCAAoC,kCAAkC,4CAA4C,4DAA4D,4CAA4C,4DAA4D,4CAA4C,4DAA4D,4CAA4C,4DAA4D,4DAA4D,oCAAoC,sCAAsC,kCAAkC,4CAA4C,oCAAoC,kDAAkD,wCAAwC,0CAA0C,kDAAkD,wCAAwC,wCAAwC,0CAA0C,kDAAkD,sDAAsD,0DAA0D,kDAAkD,kCAAkC,0DAA0D,0DAA0D,gFAAgF,gFAAgF,oEAAoE,8DAA8D,8DAA8D,4CAA4C,sDAAsD,4DAA4D,0CAA0C,oEAAoE,kEAAkE,wCAAwC,kEAAkE,gEAAgE,gDAAgD,gCAAgC,kCAAkC,kDAAkD,8BAA8B,8CAA8C,kCAAkC,0CAA0C,0DAA0D,0DAA0D,wDAAwD,oDAAoD,sCAAsC,kCAAkC,oCAAoC,8CAA8C,wDAAwD,oCAAoC,sCAAsC,oDAAoD,wDAAwD,0DAA0D,0DAA0D,0DAA0D,8DAA8D,8DAA8D,gEAAgE,gEAAgE,8CAA8C,gCAAgC,oCAAoC,wCAAwC,sDAAsD,kDAAkD,kDAAkD,sDAAsD,8CAA8C,gDAAgD,kDAAkD,0DAA0D,sDAAsD,4CAA4C,wCAAwC,0CAA0C,wCAAwC,4CAA4C,0CAA0C,4CAA4C,wCAAwC,kDAAkD,gDAAgD,uCAAuC,0BAA0B,kCAAkC,oCAAoC,gDAAgD,0CAA0C,oCAAoC,gCAAgC,4CAA4C,oDAAoD,0DAA0D,4DAA4D,4BAA4B,4DAA4D,0CAA0C,4CAA4C,0DAA0D,4CAA4C,8CAA8C,4CAA4C,8CAA8C,gDAAgD,gDAAgD,oDAAoD,wCAAwC,4BAA4B,oCAAoC,kDAAkD,sCAAsC,8CAA8C,kCAAkC,sDAAsD,0CAA0C,oCAAoC,kCAAkC,4CAA4C,qDAAqD,aAAa,EAAE,KAAK,IAAI","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,gBAAgB;AAClC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA,aAAa,uBAAuB;AACpC,oBAAoB,sDAAsD;AAC1E,2BAA2B,8EAA8E;AACzG,0BAA0B,0BAA0B;AACpD,2BAA2B,0BAA0B;AACrD,mBAAmB,cAAc;AACjC,oBAAoB,eAAe;AACnC,mBAAmB,cAAc;AACjC,oBAAoB,cAAc;AAClC,wBAAwB,cAAc;AACtC,0BAA0B,cAAc;AACxC,mBAAmB,cAAc;AACjC,oBAAoB,eAAe;AACnC,4BAA4B,eAAe;AAC3C,wBAAwB,eAAe;AACvC,gBAAgB,eAAe;AAC/B,uBAAuB,eAAe;AACtC,6BAA6B,eAAe;AAC5C,6BAA6B,eAAe;AAC5C,kCAAkC,eAAe;AACjD,oCAAoC,eAAe;AACnD,sCAAsC,eAAe;AACrD,mBAAmB,eAAe;AAClC,sBAAsB,eAAe;AACrC,sBAAsB,eAAe;AACrC,sBAAsB;AACtB;;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;;AAaC;;;ACnToK;;AAErK;AACA,SAAS,aAAa,0BAA0B,oBAAoB,GAAG,sBAAsB;;AAE7F;;AAEA,wBAAwB,eAAe;AACvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA,qBAAqB,8DAA8D;AACnF;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA,gEAAgE,uFAAuF;AACvJ,IAAI,wCAAwC;;AAE5C,qDAAqD,kCAAkC;AACvF;;AAEA;AACA;;AAEA,0EAAe;AACf;AACA;AACA;AACA;AACA,kBAAkB,mCAAmC;AACrD,kCAAkC,EAAE,eAAe;AACnD,qBAAqB,uBAAuB;AAC5C,8BAA8B,sDAAsD;AACpF,+BAA+B,aAAa;AAC5C,gCAAgC,aAAa;AAC7C,6BAA6B,eAAe;AAC5C,yBAAyB,eAAe;AACxC,8BAA8B,aAAa;AAC3C,8BAA8B,eAAe;AAC7C,gCAAgC,eAAe;AAC/C,uCAAuC;AACvC,SAAS;AACT,OAAO;AACP;AACA;AACA,kBAAkB,qCAAqC;AACvD,kCAAkC,EAAE,eAAe;AACnD,qBAAqB,uBAAuB;AAC5C,8BAA8B,wDAAwD;AACtF,+BAA+B,aAAa;AAC5C,gCAAgC,aAAa;AAC7C,6BAA6B,eAAe;AAC5C,yBAAyB,eAAe;AACxC,0BAA0B,eAAe;AACzC,2BAA2B,eAAe;AAC1C,8BAA8B,aAAa;AAC3C,gCAAgC,eAAe;AAC/C,uCAAuC;AACvC,SAAS;AACT;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,qDAAqD,yBAAyB;AAC9E,kCAAkC,EAAE,kBAAkB;AACtD;AACA;AACA;AACA;AACA,4BAA4B,yBAAyB;AACrD;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA,qDAAqD,yBAAyB;AAC9E,kCAAkC,EAAE,kBAAkB;AACtD;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,yBAAyB;AACrD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,CAAC;;;AClID;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,qFAAqF;AACrF;AACA;AACA;AACA;AACA;;AAE2M;;AAE3M;AACA,EAAE,aAAa;AACf,EAAE,oBAAoB;AACtB,EAAE,sBAAsB;;AAExB;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA,kCAAkC;AAClC;;AAEA;;AAEA,gEAAgE,uBAAuB;AACvF;;AAEA,yCAAyC,6BAA6B;AACtE;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,iCAAiC,8BAA8B;AAC/D,+BAA+B,qBAAqB;AACpD,kCAAkC,8BAA8B;AAChE;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,iEAAe;AACf;AACA;AACA;AACA,gBAAgB,qBAAqB;AACrC,gCAAgC,EAAE,eAAe;AACjD,mBAAmB,uBAAuB;AAC1C,qBAAqB,+CAA+C;AACpE,sBAAsB,uBAAuB;AAC7C,qCAAqC,uBAAuB;AAC5D,uCAAuC,uBAAuB;AAC9D,6BAA6B,aAAa;AAC1C,8BAA8B,aAAa;AAC3C,2BAA2B,eAAe;AAC1C,uBAAuB,eAAe;AACtC,wBAAwB,eAAe;AACvC,yBAAyB,eAAe;AACxC,4BAA4B,eAAe;AAC3C,8BAA8B,eAAe;AAC7C,qCAAqC,eAAe;AACpD,uBAAuB,aAAa;AACpC,wBAAwB,aAAa;AACrC,4BAA4B,aAAa;AACzC,yBAAyB,aAAa;AACtC,oBAAoB,aAAa;AACjC,+BAA+B,aAAa;AAC5C,gCAAgC,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;;;;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 0000000..2c25cfa Binary files /dev/null and b/seminar06-planning/simulator/images/examples/crosswalks.png differ 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 0000000..5967327 Binary files /dev/null and b/seminar06-planning/simulator/images/examples/dodging_a_speeder.png differ diff --git a/seminar06-planning/simulator/images/examples/lane_blockage.png b/seminar06-planning/simulator/images/examples/lane_blockage.png new file mode 100644 index 0000000..0fcf256 Binary files /dev/null and b/seminar06-planning/simulator/images/examples/lane_blockage.png differ diff --git a/seminar06-planning/simulator/images/examples/merging.png b/seminar06-planning/simulator/images/examples/merging.png new file mode 100644 index 0000000..d8c3d17 Binary files /dev/null and b/seminar06-planning/simulator/images/examples/merging.png differ diff --git a/seminar06-planning/simulator/images/examples/one_car_overtake.png b/seminar06-planning/simulator/images/examples/one_car_overtake.png new file mode 100644 index 0000000..9d62ecc Binary files /dev/null and b/seminar06-planning/simulator/images/examples/one_car_overtake.png differ diff --git a/seminar06-planning/simulator/images/examples/peloton.png b/seminar06-planning/simulator/images/examples/peloton.png new file mode 100644 index 0000000..1b25ca3 Binary files /dev/null and b/seminar06-planning/simulator/images/examples/peloton.png differ 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 0000000..c43cc81 Binary files /dev/null and b/seminar06-planning/simulator/images/examples/rough_road.png differ diff --git a/seminar06-planning/simulator/images/examples/two_car_overtake.png b/seminar06-planning/simulator/images/examples/two_car_overtake.png new file mode 100644 index 0000000..dadfa5a Binary files /dev/null and b/seminar06-planning/simulator/images/examples/two_car_overtake.png differ diff --git a/seminar06-planning/simulator/images/ladavaz.glb b/seminar06-planning/simulator/images/ladavaz.glb new file mode 100644 index 0000000..d2940a6 Binary files /dev/null and b/seminar06-planning/simulator/images/ladavaz.glb differ diff --git a/seminar06-planning/simulator/images/stone.jpg b/seminar06-planning/simulator/images/stone.jpg new file mode 100644 index 0000000..7d15098 Binary files /dev/null and b/seminar06-planning/simulator/images/stone.jpg differ diff --git a/seminar06-planning/simulator/images/wheel.png b/seminar06-planning/simulator/images/wheel.png new file mode 100644 index 0000000..4e18e5f Binary files /dev/null and b/seminar06-planning/simulator/images/wheel.png differ diff --git a/seminar06-planning/simulator/images/wheel.xcf b/seminar06-planning/simulator/images/wheel.xcf new file mode 100644 index 0000000..aa8f65b Binary files /dev/null and b/seminar06-planning/simulator/images/wheel.xcf differ diff --git a/seminar06-planning/simulator/index.html b/seminar06-planning/simulator/index.html new file mode 100644 index 0000000..0e515cc --- /dev/null +++ b/seminar06-planning/simulator/index.html @@ -0,0 +1,635 @@ + + + Dash - WebGL Self-Driving Car Simulator + + + + + +
+ + + +
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Speed
+
—
+
m/s
+
+
+
Station
+
—
+
meters
+
+
+
Latitude
+
—
+
meters
+
+
+
Plan Time
+
—
+
s
+
+
+
+
+
+ + + + — +
+
+
+ + + +
+
+ Manual + Autonomous +
+
+
+
+
+
+
+
+ +   + +
+ +
+
+
+ + + +
+
+
+ + + + + + + + + + + +
+
+
+ Edit Scenario + Load Scenario +
+
+
+ + + + +
+
+ + + +
+
+ — fps +
+
+
+
+ Chase + Top Down + Free +
+
+
+
+ 2D + 3D +
+
+
+
+
+ + + + + + + + + + + + + + + diff --git a/seminar06-planning/simulator/js/Dash.js b/seminar06-planning/simulator/js/Dash.js new file mode 100644 index 0000000..7f8e534 --- /dev/null +++ b/seminar06-planning/simulator/js/Dash.js @@ -0,0 +1,6 @@ +import Simulator from "./Simulator.js"; +import StaticObstacle from "./autonomy/StaticObstacle.js"; + +document.addEventListener('DOMContentLoaded', e => { + window.simulator = new Simulator(document.getElementById('container')); +}); diff --git a/seminar06-planning/simulator/js/GPGPU.js b/seminar06-planning/simulator/js/GPGPU.js new file mode 100644 index 0000000..e34045f --- /dev/null +++ b/seminar06-planning/simulator/js/GPGPU.js @@ -0,0 +1,542 @@ +/* Partially adapted from https://github.com/turbo/js/blob/master/turbo.js + * + * Turbo.js License: + * Copyright (c) 2016 minxomat + * + * 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. + */ + +const vertexShaderCode = `#version 300 es +in vec2 position; +in vec2 texture; +out vec2 kernelPosition; + +void main(void) { + kernelPosition = texture; + gl_Position = vec4(position.xy, 0.0, 1.0); +} +`; + +const fragmentShaderHeader = `#version 300 es +precision highp float; +precision highp int; +precision highp sampler2D; +precision highp sampler2DArray; +precision highp sampler3D; +precision highp samplerCube; + +in vec2 kernelPosition; +out vec4 kernelOut; +uniform ivec2 kernelSize; +`; + +export default class GPGPU { + static alloc(size, stride) { + if (!Number.isInteger(stride) || stride < 1 || stride > 4) + throw new Error("Data stride must be an integer between 1 and 4."); + + // Find the smallest perfect square greater than or equal to size + const squareSize = Math.pow(Math.ceil(Math.sqrt(size)), 2); + + const data = new Float32Array(squareSize * stride); + data.gpgpuSize = size; + data.gpgpuStride = stride; + return data; + } + + constructor(configs, shared = {}) { + this._setUpGL(); + + this.outputTextures = {}; + this.sharedTextures = {}; + + this.programs = configs.map(c => this._prepareProgram(c)); + + for (const name in shared) { + const options = shared[name]; + const { width, height, channels, data } = options; + this.sharedTextures[name] = this._createTexture(data, width, height, channels, options); + } + } + + updateSharedTextures(shared) { + this.sharedTextures = {}; + + for (const name in shared) { + const options = shared[name]; + const { width, height, channels, data } = options; + if (this.sharedTextures[name]) this.gl.deleteTexture(this.sharedTextures[name]); + this.sharedTextures[name] = this._createTexture(data, width, height, channels, options); + } + } + + updateProgram(programOrProgramIndex, config) { + const program = typeof(programOrProgramIndex) == 'number' ? this.programs[programOrProgramIndex] : programOrProgramIndex; + + if (!program) + throw new Error(`Program with index ${programOrProgramIndex} does not exist.`); + + if (config.inputs) + throw new Error('The `updateProgram` function cannot be used to update inputs. Use `updateProgramInputs` instead.'); + + if (config.meta) + program.meta = Object.assign(program.meta, config.meta); + + if (config.width !== undefined && config.height !== undefined) + this.updateProgramSize(program, config.width, config.height); + + if (typeof(config.uniforms) == 'object') + this.updateProgramUniforms(program, config.uniforms); + } + + updateProgramInputs(programIndex, inputs) { + const program = this.programs[programIndex]; + + if (!program) + throw new Error(`Program with index ${programIndex} does not exist.`); + + if (program.inputTextures.length != inputs.length) + throw new Error(`You must provide the same number of inputs as when the program was set up: got ${inputs.length} but expected ${program.inputTextures.length}.`); + + const previousInputWidth = program.inputWidth; + const previousInputHeight = program.inputHeight; + + const config = program.config; + + if (config.width === undefined || config.height === undefined) { + program.inputWidth = undefined; + program.inputHeight = undefined; + program.inputDataSize = undefined; + } + + this._prepareProgramInputs(program, inputs); + + if (program.inputWidth != previousInputWidth || program.inputHeight != previousInputHeight) { + this.gl.useProgram(program.glProgram); + this.gl.uniform2i(program.kernelSizeLocation, program.inputWidth, program.inputHeight); + this._prepareProgramOutput(program); + } + } + + updateProgramSize(programOrProgramIndex, width, height) { + const program = typeof(programOrProgramIndex) == 'number' ? this.programs[programOrProgramIndex] : programOrProgramIndex; + + if (!program) + throw new Error(`Program with index ${programOrProgramIndex} does not exist.`); + + if (program.inputTextures.length != 0) + throw new Error(`Size can only be updated on programs with no inputs.`); + + if (width == program.inputWidth && height == program.inputHeight) return; + + program.inputWidth = width; + program.inputHeight = height; + program.inputDataSize = width * height; + + this.gl.useProgram(program.glProgram); + this.gl.uniform2i(program.kernelSizeLocation, program.inputWidth, program.inputHeight); + this._prepareProgramOutput(program); + } + + updateProgramUniforms(programOrProgramIndex, uniforms) { + const program = typeof(programOrProgramIndex) == 'number' ? this.programs[programOrProgramIndex] : programOrProgramIndex; + this.gl.useProgram(program.glProgram); + + if (!program) + throw new Error(`Program with index ${programOrProgramIndex} does not exist.`); + + for (const uniformName in uniforms) { + const value = uniforms[uniformName]; + let uniform; + + if (uniform = program.uniforms[uniformName]) { + this._setUniform(uniform.type, uniform.location, value) + } else if (uniform = program.uniformTextures[uniformName]) { + if (typeof(value) != 'object' || value.type != 'texture') + throw new Error(`Expected texture type for uniform ${uniformName}.`); + + const { width, height, channels, data } = uniform; + if (program.uniformTextures[uniformName].texture) this.gl.deleteTexture(program.uniformTextures[uniformName].texture); + program.uniformTextures[uniformName].texture = this._createTexture(data, width, height, channels, uniform); + } else { + throw new Error(`The uniform ${uniformName} does not exist in this program.`); + } + } + } + + run() { + const outputs = []; + + for (const program of this.programs) { + this.gl.useProgram(program.glProgram); + this.gl.viewport(0, 0, program.inputWidth, program.inputHeight); + this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, program.frameBuffer); + + for (const [index, inputTexture] of program.inputTextures.entries()) { + this.gl.activeTexture(this.gl.TEXTURE0 + index); + this.gl.bindTexture(this.gl.TEXTURE_2D, inputTexture); + } + + for (const uniformName in program.uniformTextures) { + const uniformTexture = program.uniformTextures[uniformName]; + this.gl.activeTexture(this.gl.TEXTURE0 + uniformTexture.index); + this.gl.bindTexture(uniformTexture.target, uniformTexture.texture || this.sharedTextures[uniformTexture.name] || this.outputTextures[uniformTexture.name]); + } + + if (typeof(program.draw) == 'function') { + program.draw(this, program); + } else { + this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.textureBuffer); + this.gl.enableVertexAttribArray(program.textureLocation); + this.gl.vertexAttribPointer(program.textureLocation, 2, this.gl.FLOAT, false, 0, 0); + this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.positionBuffer); + this.gl.enableVertexAttribArray(program.positionLocation); + this.gl.vertexAttribPointer(program.positionLocation, 2, this.gl.FLOAT, false, 0, 0); + this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer); + + if (program.drawProxy) { + const draw = (() => this.gl.drawElements(this.gl.TRIANGLES, 6, this.gl.UNSIGNED_SHORT, 0)).bind(this); + program.drawProxy(this, program, draw); + } else { + this.gl.drawElements(this.gl.TRIANGLES, 6, this.gl.UNSIGNED_SHORT, 0); + } + } + + if (program.output && program.output.name && !program.output.read) { + outputs.push(null); + } else { + const output = new Float32Array(program.inputWidth * program.inputHeight * 4); + this.gl.readPixels(0, 0, program.inputWidth, program.inputHeight, this.gl.RGBA, this.gl.FLOAT, output); + outputs.push(output.subarray(0, program.inputDataSize * 4)); + } + } + + return outputs; + } + + _setUpGL() { + let canvas; + + if (self.document) + canvas = document.createElement('canvas'); + else if (self.OffscreenCanvas) + canvas = new OffscreenCanvas(0, 0); + else + throw new Error('Could not create a canvas.'); + + const attr = { alpha: false, antialias: false }; + this.gl = canvas.getContext("webgl2", attr) || canvas.getContext("experimental-webgl2", attr); + + if (!this.gl) + throw new Error("Unable to initialize WebGL2. Your browser may not support it."); + + if (!this.gl.getExtension('EXT_color_buffer_float')) + throw new Error('Required WebGL extension EXT_color_buffer_float not supported.'); + + if (!this.gl.getExtension('OES_texture_float_linear')) + throw new Error('Required WebGL extension OES_texture_float_linear not supported.'); + + this.positionBuffer = this._newBuffer([-1, -1, 1, -1, 1, 1, -1, 1]); + this.textureBuffer = this._newBuffer([0, 0, 1, 0, 1, 1, 0, 1]); + this.indexBuffer = this._newBuffer([1, 2, 0, 3, 0, 2], Uint16Array, this.gl.ELEMENT_ARRAY_BUFFER); + } + + _prepareProgram(config) { + const program = { config }; + + program.draw = config.draw; + program.drawProxy = config.drawProxy; + program.meta = Object.assign({}, config.meta); + + if (config.width && config.height) { + program.inputWidth = config.width; + program.inputHeight = config.height; + program.inputDataSize = config.width * config.height; + } + + program.output = config.output; + + const kernel = config.kernel; + + if (typeof(kernel) != 'string' || kernel.length == 0) + throw new Error("Kernel code cannot be empty."); + + const inputs = config.inputs || []; + const uniforms = config.uniforms || {}; + + this._prepareProgramInputs(program, inputs); + + let fragmentShaderConfig = ""; + + for (const index in inputs) + fragmentShaderConfig += `uniform sampler2D _input${index};\n`; + + if (program.inputWidth === undefined || program.inputHeight === undefined) + throw new Error("Unknown kernel size. You must provide either an input or the `width` and `height` parameters in the kernel config."); + + program.uniformTextures = {}; + program.uniforms = {}; + + for (const uniformName in uniforms) { + const uniform = uniforms[uniformName]; + + if (typeof(uniform) == 'number') { + program.uniforms[uniformName] = { + type: 'float', + value: uniform + }; + fragmentShaderConfig += `uniform float ${uniformName};\n`; + } else if (Array.isArray(uniform)) { + if (uniform.length < 2 || uniform.length > 4) + throw new Error(`Array uniforms can only have lengths of 2, 3, or 4 elements (corresponding to vec2, vec3, and vec4).`); + + const type = ['vec2', 'vec3', 'vec4'][uniform.length - 2]; + program.uniforms[uniformName] = { + type: type, + value: uniform + }; + fragmentShaderConfig += `uniform ${type} ${uniformName};\n`; + } else { + const { type, width, height, channels, data, value, length, name } = uniform; + + if (type == 'texture' || type == 'outputTexture' || type == 'sharedTexture') { + let target, type; + + if (uniform.textureType == '3D') { + target = this.gl.TEXTURE_3D; + type = 'sampler3D'; + } else if (uniform.textureType == '2DArray') { + target = this.gl.TEXTURE_2D_ARRAY; + type = 'sampler2DArray'; + } else { + target = this.gl.TEXTURE_2D; + type = 'sampler2D'; + } + + if (type == 'texture') { + program.uniformTextures[uniformName] = { target, texture: data ? this._createTexture(data, width, height, channels, uniform) : null }; + } else { + program.uniformTextures[uniformName] = { target, texture: null, name: name || uniformName }; + } + + fragmentShaderConfig += `uniform ${type} ${uniformName};\n`; + } else { + program.uniforms[uniformName] = { type, value }; + if (length !== undefined) + fragmentShaderConfig += `uniform ${type} ${uniformName}[${length}];\n`; + else + fragmentShaderConfig += `uniform ${type} ${uniformName};\n`; + } + } + } + + const vertexShader = this.gl.createShader(this.gl.VERTEX_SHADER); + this.gl.shaderSource(vertexShader, config.vertexShader || vertexShaderCode); + this.gl.compileShader(vertexShader); + + if (!this.gl.getShaderParameter(vertexShader, this.gl.COMPILE_STATUS)) { + throw new Error( + "Could not build vertex shader (fatal).\n" + "\n" + + "--- CODE DUMP ---\n" + (config.vertexShader || vertexShaderCode) + "\n\n" + + "--- ERROR LOG ---\n" + this.gl.getShaderInfoLog(vertexShader) + ); + } + + const fragmentShaderMain = ` +void main() { + kernelOut = vec4(kernel(${[...Array(inputs.length).keys()].map(i => `texture(_input${i}, kernelPosition)`).join(', ')})); +} + `; + + const fragmentShader = this.gl.createShader(this.gl.FRAGMENT_SHADER); + const fragmentShaderSource = fragmentShaderHeader + fragmentShaderConfig + kernel + fragmentShaderMain; + this.gl.shaderSource(fragmentShader, fragmentShaderSource); + this.gl.compileShader(fragmentShader); + + if (!this.gl.getShaderParameter(fragmentShader, this.gl.COMPILE_STATUS)) { + const source = fragmentShaderSource.split('\n'); + let dbgMsg = "ERROR: Could not build shader (fatal).\n\n------------------ KERNEL CODE DUMP ------------------\n" + + for (let l = 0; l < source.length; l++) + dbgMsg += `${l + 1}> ${source[l]}\n`; + + dbgMsg += "\n--------------------- ERROR LOG ---------------------\n" + this.gl.getShaderInfoLog(fragmentShader); + + throw new Error(dbgMsg); + } + + program.glProgram = this.gl.createProgram(); + this.gl.attachShader(program.glProgram, vertexShader); + this.gl.attachShader(program.glProgram, fragmentShader); + this.gl.linkProgram(program.glProgram); + this.gl.useProgram(program.glProgram); + + if (!this.gl.getProgramParameter(program.glProgram, this.gl.LINK_STATUS)) + throw new Error('Failed to link GLSL program code.'); + + let textureIndex = 0; + + for (const input of program.inputTextures) { + const location = this.gl.getUniformLocation(program.glProgram, `_input${textureIndex}`); + this.gl.uniform1i(location, textureIndex); + textureIndex++; + } + + for (const uniformName in program.uniformTextures) { + program.uniformTextures[uniformName].index = textureIndex; + const location = this.gl.getUniformLocation(program.glProgram, uniformName); + this.gl.uniform1i(location, textureIndex); + textureIndex++; + } + + for (const uniformName in program.uniforms) { + const { type, value } = program.uniforms[uniformName]; + const location = program.uniforms[uniformName].location = this.gl.getUniformLocation(program.glProgram, uniformName); + + if (value !== undefined) + this._setUniform(type, location, value); + + delete program.uniforms[uniformName].value; + } + + program.kernelSizeLocation = this.gl.getUniformLocation(program.glProgram, 'kernelSize'); + this.gl.uniform2i(program.kernelSizeLocation, program.inputWidth, program.inputHeight); + + program.positionLocation = this.gl.getAttribLocation(program.glProgram, 'position'); + program.textureLocation = this.gl.getAttribLocation(program.glProgram, 'texture'); + + program.frameBuffer = this.gl.createFramebuffer(); + this._prepareProgramOutput(program); + + return program; + } + + _prepareProgramInputs(program, inputs) { + if (program.inputTextures) + program.inputTextures.forEach(t => this.gl.deleteTexture(t)); + + program.inputTextures = []; + + for (const [index, data] of inputs.entries()) { + if (data.gpgpuSize === undefined || data.gpgpuStride === undefined) + throw new Error('GPGPU inputs must be created by the `alloc` function.'); + + const size = Math.sqrt(data.length / data.gpgpuStride); + if (size <= 0 || size % 1 != 0) + throw new Error('GPGPU input size is expected to be a perfect square.'); + + if (program.inputWidth === undefined || program.inputHeight === undefined) { + program.inputWidth = size; + program.inputHeight = size; + program.inputDataSize = data.gpgpuSize; + } else if (size != program.inputWidth || size != program.inputHeight) { + throw new Error(`All GPGPU inputs must be of the same size. Received ${data.gpgpuSize} (internal ${size * size}) but expected ${program.inputDataSize} (internal ${program.inputWidth * program.inputHeight}).`); + } + + program.inputTextures.push(this._createTexture(data, size, size, data.gpgpuStride)); + } + } + + _prepareProgramOutput(program) { + this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, program.frameBuffer); + + const outputTexture = this._createTexture(null, program.inputWidth, program.inputHeight, 4, program.output); + + if (program.output && program.output.textureType !== '3D' && program.output.textureType !== '2DArray') { + this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, this.gl.COLOR_ATTACHMENT0, this.gl.TEXTURE_2D, outputTexture, 0); + const frameBufferStatus = (this.gl.checkFramebufferStatus(this.gl.FRAMEBUFFER) == this.gl.FRAMEBUFFER_COMPLETE); + if (!frameBufferStatus) + throw new Error('Error attaching float texture to framebuffer. Your device is probably incompatible.'); + } + + if (program.outputTexture !== undefined) + this.gl.deleteTexture(program.outputTexture); + program.outputTexture = outputTexture; + + if (program.output && program.output.name) + this.outputTextures[program.output.name] = outputTexture; + } + + _setUniform(type, location, value) { + switch (type) { + case 'int': this.gl.uniform1i(location, value); break; + case 'float': Array.isArray(value) ? this.gl.uniform1fv(location, value) : this.gl.uniform1f(location, value); break; + case 'vec2': this.gl.uniform2fv(location, value); break; + case 'vec3': this.gl.uniform3fv(location, value); break; + case 'vec4': this.gl.uniform4fv(location, value); break; + case 'mat3': this.gl.uniformMatrix3fv(location, value); break; + default: throw new Error(`Unknown uniform type ${type}.`); + } + } + + _newBuffer(data, klass, target) { + const buf = this.gl.createBuffer(); + + this.gl.bindBuffer((target || this.gl.ARRAY_BUFFER), buf); + this.gl.bufferData((target || this.gl.ARRAY_BUFFER), new (klass || Float32Array)(data), this.gl.STATIC_DRAW); + + return buf; + } + + _createTexture(data, width, height, channels, options = {}) { + const texture = this.gl.createTexture(); + + let internalFormat, format; + + switch (channels) { + case 1: + internalFormat = this.gl.R32F; + format = this.gl.RED; + break; + case 2: + internalFormat = this.gl.RG32F; + format = this.gl.RG; + break; + case 3: + internalFormat = this.gl.RGB32F; + format = this.gl.RGB; + break; + case 4: + internalFormat = this.gl.RGBA32F; + format = this.gl.RGBA; + break; + default: + throw("Texture channels must between 1 and 4."); + } + + const target = options.textureType == '3D' ? this.gl.TEXTURE_3D : options.textureType == '2DArray' ? this.gl.TEXTURE_2D_ARRAY : this.gl.TEXTURE_2D; + + this.gl.bindTexture(target, texture); + this.gl.texParameteri(target, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE); + this.gl.texParameteri(target, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE); + this.gl.texParameteri(target, this.gl.TEXTURE_WRAP_R, this.gl.CLAMP_TO_EDGE); + this.gl.texParameteri(target, this.gl.TEXTURE_MIN_FILTER, options.filter == 'linear' ? this.gl.LINEAR : this.gl.NEAREST); + this.gl.texParameteri(target, this.gl.TEXTURE_MAG_FILTER, options.filter == 'linear' ? this.gl.LINEAR : this.gl.NEAREST); + + if (options.textureType == '3D' || options.textureType == '2DArray') { + this.gl.texImage3D(target, 0, internalFormat, width, height, options.depth, 0, format, this.gl.FLOAT, data); + } else { + this.gl.texImage2D(target, 0, internalFormat, width, height, 0, format, this.gl.FLOAT, data); + } + + this.gl.bindTexture(target, null); + + return texture; + } +} diff --git a/seminar06-planning/simulator/js/Helpers.js b/seminar06-planning/simulator/js/Helpers.js new file mode 100644 index 0000000..813084d --- /dev/null +++ b/seminar06-planning/simulator/js/Helpers.js @@ -0,0 +1,5 @@ +function formatDate(date) { + return date && date.toLocaleDateString(undefined, {month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: 'numeric', hour12: true}); +} + +export { formatDate }; diff --git a/seminar06-planning/simulator/js/Simulator.js b/seminar06-planning/simulator/js/Simulator.js new file mode 100644 index 0000000..0458c61 --- /dev/null +++ b/seminar06-planning/simulator/js/Simulator.js @@ -0,0 +1,939 @@ +import Physics from "./physics/Physics.js"; +import Path from "./autonomy/Path.js"; +import CubicPath from "./autonomy/path-planning/CubicPath.js"; +import AutonomousController from "./autonomy/control/AutonomousController.js"; +import FollowController from "./autonomy/control/FollowController.js"; +import ManualController from "./autonomy/control/ManualController.js"; +import MapObject from "./objects/MapObject.js"; +import CarObject from "./objects/CarObject.js"; +import StaticObstacleObject from "./objects/StaticObstacleObject.js"; +import DynamicObstacleObject from "./objects/DynamicObstacleObject.js"; +import Editor from "./simulator/Editor.js"; +import OrbitControls from "./simulator/OrbitControls.js"; +import TopDownCameraControls from "./simulator/TopDownCameraControls.js"; +import Dashboard from "./simulator/Dashboard.js"; +import GPGPU from "./GPGPU.js"; +import RoadLattice from "./autonomy/path-planning/RoadLattice.js"; +import PathPlanner from "./autonomy/path-planning/PathPlanner.js"; +import StaticObstacle from "./autonomy/StaticObstacle.js"; +import DynamicObstacle from "./autonomy/DynamicObstacle.js"; +import MovingAverage from "./autonomy/MovingAverage.js"; +import PathPlannerConfigEditor from "./simulator/PathPlannerConfigEditor.js"; +import Car from "./physics/Car.js"; + +import Utils from "script-loader!./Utils.js"; + +const WELCOME_MODAL_KEY = 'dash_WelcomeModal'; + +import EXAMPLES from "./simulator/examples.js"; + +export default class Simulator { + constructor(domElement) { + this.pathPlannerWorker = new Worker(URL.createObjectURL(new Blob([`(${dash_initPathPlannerWorker.toString()})()`], { type: 'text/javascript' }))); + this.pathPlannerWorker.onmessage = this.receivePlannedPath.bind(this); + this.pathPlannerConfigEditor = new PathPlannerConfigEditor(); + + this.physics = new Physics(); + this.car = this.physics.createCar(); + + this.renderer = new THREE.WebGLRenderer({ antialias: true }); + this.renderer.setPixelRatio(window.devicePixelRatio); + this.renderer.setSize(domElement.clientWidth, domElement.clientHeight); + this.renderer.shadowMap.enabled = true; + domElement.appendChild(this.renderer.domElement); + + this.lastPlanParams = null; + this.renderer.context.canvas.addEventListener('webglcontextlost', event => { + console.log('Simulator: webgl context lost'); + console.log(event); + console.log(this.lastPlanParams); + }); + + this._setUpCameras(this.renderer.domElement); + + this.scene = new THREE.Scene(); + this.sceneFog = null;//new THREE.FogExp2(0x111111, 0.0025); + this.scene.fog = this.sceneFog; + this.scene.background = new THREE.Color(0x111111); + + this.editor = new Editor(this.renderer.domElement, this.editorCamera, this.scene); + + const geolocation = null;//[33.523900, -111.908756]; + const map = new MapObject(geolocation); + this.scene.add(map); + + this.carObject = new CarObject(this.car); + this.scene.add(this.carObject); + + this.scene.add(new THREE.AmbientLight(0x666666)); + const light = new THREE.DirectionalLight(0xffffff, 0.75); + light.position.set(1, 1, 1).normalize(); + this.scene.add(light); + + this.manualCarController = new ManualController(); + this.autonomousCarController = null; + + this.dashboard = new Dashboard(this.car); + + this.plannerReady = false; + this.plannerRunning = false; + this.plannerReset = false; + this.carStation = null; + this.plannedPathGroup = new THREE.Group(); + this.scene.add(this.plannedPathGroup); + + this.staticObstaclesGroup = new THREE.Group(); + this.scene.add(this.staticObstaclesGroup); + this.dynamicObstaclesGroup = new THREE.Group(); + this.scene.add(this.dynamicObstaclesGroup); + + this.paused = false; + this.prevTimestamp = null; + this.frameCounter = 0; + this.fpsTime = 0; + this.fps = 0; + this.simulatedTime = 0; + this.lastPlanRequestTime = null; + this.latestPlanTimestamp = null; + this.averagePlanTime = new MovingAverage(20); + + window.addEventListener('resize', e => { + this._updateCameraAspects(domElement.clientWidth / domElement.clientHeight); + this.renderer.setSize(domElement.clientWidth, domElement.clientHeight); + }); + + window.addEventListener('hashchange', e => { + if (window.location.hash.startsWith('#/s/')) + window.location.reload(); + }); + + this.manualModeButton = document.getElementById('mode-manual'); + this.manualModeButton.addEventListener('click', this.enableManualMode.bind(this)); + this.autonomousModeButton = document.getElementById('mode-autonomous'); + this.autonomousModeButton.addEventListener('click', this.enableAutonomousMode.bind(this)); + + document.getElementById('editor-enable').addEventListener('click', this.enableEditor.bind(this)); + document.getElementById('editor-finalize').addEventListener('click', this.finalizeEditor.bind(this)); + document.getElementById('simulator-load').addEventListener('click', this.loadScenario.bind(this)); + + this.scenarioPlayButton = document.getElementById('scenario-play'); + this.scenarioPlayButton.addEventListener('click', this.playScenario.bind(this)); + this.scenarioPauseButton = document.getElementById('scenario-pause'); + this.scenarioPauseButton.addEventListener('click', this.pauseScenario.bind(this)); + for (const btn of document.querySelectorAll('[id=scenario-restart]')) { + btn.addEventListener('click', this.restartScenario.bind(this)); + } + + this.welcomeModal = document.getElementById('welcome-modal'); + document.getElementById('show-welcome-modal').addEventListener('click', e => this.welcomeModal.classList.add('is-active')); + + // if (window.localStorage.getItem(WELCOME_MODAL_KEY) !== 'hide') { + // this.welcomeModal.classList.add('is-active'); + // } + + this.collisionMessage = document.getElementById('collision-message'); + this.successMessage = document.getElementById('success-message'); + // If the click was outside the div, hide it + document.addEventListener("click", this.setHideCollisionMessageOnClickOutside.bind(this)); + + document.getElementById('welcome-modal-background').addEventListener('click', this.hideWelcomeModal.bind(this)); + document.getElementById('welcome-modal-close').addEventListener('click', this.hideWelcomeModal.bind(this)); + + document.getElementById('welcome-modal-examples').addEventListener('click', e => { + this.welcomeModal.classList.remove('is-active'); + this.loadScenario(); + this.editor.scenarioManager.switchTab(this.editor.scenarioManager.examplesTab); + }); + + document.getElementById('welcome-modal-create').addEventListener('click', e => { + this.welcomeModal.classList.remove('is-active'); + this.enableEditor(); + }); + + this.simModeBoxes = Array.prototype.slice.call(document.getElementsByClassName('sim-mode-box'), 0); + this.editModeBoxes = Array.prototype.slice.call(document.getElementsByClassName('edit-mode-box'), 0); + + this.fpsBox = document.getElementById('fps'); + + this.enableManualMode(); + this.changeCamera('chase'); + + this.aroundAnchorIndex = null; + this.staticObstacles = []; + this.dynamicObstacles = []; + + this._checkHashScenario(); + + requestAnimationFrame(this.step.bind(this)); + + this.editor.scenarioManager._loadScenario(EXAMPLES[2]); + this.finalizeEditor(); + } + + toss() { + const pose = this.car.pose; + const rotVec = THREE.Vector2.fromAngle(pose.rot); + const pos = rotVec.clone().multiplyScalar(50).add(new THREE.Vector2(rotVec.y, rotVec.x)).add(pose.pos); + const obstacle = new StaticObstacle(pos, 0, 1.0, 1.0); + + const obsGeom = new THREE.PlaneGeometry(obstacle.width, obstacle.height); + const obsMat = new THREE.MeshBasicMaterial({ color: 0x0000ff, depthTest: false, transparent: true, opacity: 0.5 }); + const obsObj = new THREE.Mesh(obsGeom, obsMat); + obsObj.rotation.x = -Math.PI / 2; + obsObj.rotation.z = -obstacle.rot; + obsObj.position.set(obstacle.pos.x, 0, obstacle.pos.y); + this.scene.add(obsObj); + + this.staticObstacles.push(obstacle); + } + + _checkHashScenario() { + if (!window.location.hash.startsWith('#/s/')) return; + + const [_hash, _s, code] = window.location.hash.split('/'); + + try { + const json = JSON.parse(atob(decodeURIComponent(code))); + this.editor.loadJSON(json); + this.finalizeEditor(); + this.welcomeModal.classList.remove('is-active'); + window.location.hash = ''; + } catch (e) { + console.log('Error importing scenario code:'); + console.log(code); + console.log(e); + } + } + + _setUpCameras(domElement) { + this.chaseCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000); + this.chaseCameraControls = new OrbitControls(this.chaseCamera, domElement); + this.chaseCameraControls.minDistance = 4; + this.chaseCameraControls.maxDistance = 5000; + this.chaseCameraControls.maxPolarAngle = Math.PI / 2.02; + this.chaseCameraControls.enablePan = false; + this.chaseCameraControls.enabled = false; + this._resetChaseCamera(); + + this.freeCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000); + this.freeCameraControls = new OrbitControls(this.freeCamera, domElement); + this.freeCameraControls.minDistance = 5; + this.freeCameraControls.maxDistance = 5000; + this.freeCameraControls.maxPolarAngle = Math.PI / 2.02; + this.freeCameraControls.enabled = true; + this._resetFreeCamera(); + + this.topDownCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000); + this.topDownCamera.position.set(0, 50, 0); + this.topDownCamera.lookAt(0, 0, 0); + this.topDownControls = new TopDownCameraControls(domElement, this.topDownCamera); + this.topDownControls.enabled = false; + this.topDownControls.minAltitude = 5; + this.topDownControls.maxAltitude = 10000; + + this.editorCamera = new THREE.PerspectiveCamera(45, domElement.clientWidth / domElement.clientHeight, 1, 10000); + this.editorCamera.layers.enable(2); + this.editorCamera.position.set(0, 200, 0); + this.editorCamera.lookAt(0, 0, 0); + this.editorCameraControls = new TopDownCameraControls(domElement, this.editorCamera); + this.editorCameraControls.enabled = false; + this.editorCameraControls.enablePanning = true; + this.editorCameraControls.minAltitude = 10; + this.editorCameraControls.maxAltitude = 10000; + + this.cameraButtons = {}; + + ['free', 'chase', 'topDown'].forEach(c => { + const cameraButton = document.getElementById(`camera-${c}`); + cameraButton.addEventListener('click', () => this.changeCamera(c)); + this.cameraButtons[c] = cameraButton; + }); + + this.switchTo2DButton = document.getElementById('camera-2D'); + this.switchTo2DButton.addEventListener('click', this.switchTo2D.bind(this)); + this.switchTo3DButton = document.getElementById('camera-3D'); + this.switchTo3DButton.addEventListener('click', this.switchTo3D.bind(this)); + + this.switchTo3D(); + } + + _resetFreeCamera() { + this.freeCameraControls.position0.copy(this.chaseCamera.position); + const carPosition = this.car.position; + this.freeCameraControls.target0.set(carPosition.x, 0, carPosition.y); + this.freeCameraControls.reset(); + } + + _resetChaseCamera() { + const pos = this.car.position; + const dirVector = THREE.Vector2.fromAngle(this.car.rotation).multiplyScalar(-20); + this.chaseCamera.position.set(pos.x + dirVector.x, 8, pos.y + dirVector.y); + this.chaseCamera.lookAt(pos.x, 0, pos.y); + } + + _resetTopDownCamera() { + const carPosition = this.car.position; + this.topDownCamera.position.set(carPosition.x, 50, carPosition.y); + this.topDownCamera.rotation.z = -this.car.rotation - Math.PI / 2 + } + + _updateCameraAspects(aspect) { + this.freeCamera.aspect = aspect; + this.freeCamera.updateProjectionMatrix(); + this.chaseCamera.aspect = aspect; + this.chaseCamera.updateProjectionMatrix(); + this.topDownCamera.aspect = aspect; + this.topDownCamera.updateProjectionMatrix(); + this.editorCamera.aspect = aspect; + this.editorCamera.updateProjectionMatrix(); + } + + enableEditor() { + this.editor.enabled = true; + this.plannerRunning = false; + + this.previousCamera = this.camera; + this.camera = this.editorCamera; + this.editorCameraControls.enabled = true; + this.chaseCameraControls.enabled = false; + this.topDownControls.enabled = false; + this.freeCameraControls.enabled = false; + + this.scene.fog = null; + this.carObject.visible = false; + if (this.plannedPathGroup) this.plannedPathGroup.visible = false; + this.staticObstaclesGroup.visible = false; + this.dynamicObstaclesGroup.visible = false; + + this.simModeBoxes.forEach(el => el.classList.add('is-hidden')); + this.editModeBoxes.forEach(el => el.classList.remove('is-hidden')); + + this.showPlannerUnavailable(false); + } + + finalizeEditor(replaceCamera = true) { + this.editor.enabled = false; + this.editorCameraControls.enabled = false; + + this.latestPlanTimestamp = null; + this.prevTimestamp = null; + + this.scene.fog = this.sceneFog; + this.carObject.visible = true; + + this.simModeBoxes.forEach(el => el.classList.remove('is-hidden')); + this.editModeBoxes.forEach(el => el.classList.add('is-hidden')); + + if (this.editor.lanePath.anchors.length > 1) { + const centerline = this.editor.lanePath.centerline; + const pos = centerline[0].clone(); + const dir = centerline[1].clone().sub(centerline[0]); + const rot = Math.atan2(dir.y, dir.x); + const perpindicular = rot + Math.PI / 2 * (Math.sign(this.editor.lanePreference) || 0); + const latitude = this.pathPlannerConfigEditor.config.roadWidth / 4; + + this.car.setPose(pos.x + Math.cos(perpindicular) * latitude, pos.y + Math.sin(perpindicular) * latitude, rot); + this.car.velocity = this.editor.initialSpeed; + + this.dynamicObstacles = this.editor.dynamicObstacles; + + // The `false` value means the controller is waiting to be created after the first planning cycle. + // This signals the simulator to use neutral controls instead of the hard brake used for the `null` value. + this.autonomousCarController = false; + this.enableAutonomousMode(); + + if (!this.plannerRunning) { + this.plannerReady = true; + this.plannerRunning = true; + } + this.plannerReset = true; + this.simulatedTime = 0; + this.carStation = 0; + this.aroundAnchorIndex = null; + + this.pauseScenario(); + this.autonomousModeButton.classList.add('is-loading'); + this.waitingForFirstPlan = true; + } else { + this.dynamicObstacles = []; + } + + this.staticObstacles = this.editor.staticObstacles; + this.recreateStaticObstacleObjects(); + this.recreateDynamicObstacleObjects(); + + this.dashboard.update({ steer: 0, brake: 0, gas: 0 }, this.car.velocity, null, null, 0, this.averagePlanTime.average); + + if (replaceCamera) { + this.camera = this.previousCamera; + + if (this.previousCamera == this.chaseCamera) + this.chaseCameraControls.enabled = true; + else if (this.previousCamera == this.topDownCamera) + this.topDownControls.enabled = true; + else if (this.previousCamera == this.freeCamera) + this.freeCameraControls.enabled = true; + else + this.changeCamera('chase'); + } + + this._resetFreeCamera(); + this._resetChaseCamera(); + this._resetTopDownCamera(); + } + + recreateStaticObstacleObjects() { + this.scene.remove(this.staticObstaclesGroup); + this.staticObstaclesGroup = new THREE.Group(); + this.scene.add(this.staticObstaclesGroup); + + this.staticObstacles.forEach(o => { + const obstacleObject = new StaticObstacleObject(o); + this.staticObstaclesGroup.add(obstacleObject); + }); + } + + recreateDynamicObstacleObjects() { + this.scene.remove(this.dynamicObstaclesGroup); + this.dynamicObstaclesGroup = new THREE.Group(); + this.scene.add(this.dynamicObstaclesGroup); + + this.dynamicObstacles.forEach(o => { + const obstacleObject = new DynamicObstacleObject(o, this.editor.lanePath); + this.dynamicObstaclesGroup.add(obstacleObject); + }); + + this.updateDynamicObjects(this.simulatedTime); + } + + updateDynamicObjects(time) { + this.dynamicObstaclesGroup.children.forEach(o => o.update(time)); + } + + playScenario() { + this.paused = false; + this.scenarioPlayButton.classList.add('is-hidden'); + this.scenarioPauseButton.classList.remove('is-hidden'); + this.showPlannerUnavailable(false); + } + + pauseScenario() { + this.paused = true; + this.scenarioPlayButton.classList.remove('is-hidden'); + this.scenarioPauseButton.classList.add('is-hidden'); + + this.showPlannerUnavailable(false); + this.waitingForFirstPlan = false; + } + + restartScenario() { + if (this.editor.enabled) return; + + if (this.plannedPathGroup) + this.scene.remove(this.plannedPathGroup); + + this.finalizeEditor(false); + + this.successMessage.classList.remove('is-active'); + this.collisionMessage.classList.remove('is-active'); + + this.latestPlanTimestamp = null; + this.showPlannerUnavailable(false); + } + + loadScenario() { + if (this.editor.enabled) return; + + this.editor.scenarioManager.showModal(this.finalizeEditor.bind(this)); + } + + enableManualMode() { + this.manualModeButton.classList.remove('is-outlined'); + this.manualModeButton.classList.add('is-selected'); + this.autonomousModeButton.classList.add('is-outlined', 'is-inverted'); + this.autonomousModeButton.classList.remove('is-selected', 'is-link'); + + this.carControllerMode = 'manual'; + + this.showPlannerUnavailable(false); + } + + enableAutonomousMode() { + this.autonomousModeButton.classList.remove('is-outlined', 'is-inverted'); + this.autonomousModeButton.classList.add('is-selected', 'is-link'); + this.manualModeButton.classList.add('is-outlined'); + this.manualModeButton.classList.remove('is-selected'); + + this.carControllerMode = 'autonomous'; + } + + changeCamera(mode) { + if (this.editor.enabled) return; + + switch (mode) { + case "free": + this.chaseCameraControls.enabled = false; + this.topDownControls.enabled = false; + this.freeCameraControls.enabled = true; + + if (this.camera == this.freeCamera) + this._resetFreeCamera(); + else + this.camera = this.freeCamera; + + break; + case "chase": + this.freeCameraControls.enabled = false; + this.topDownControls.enabled = false; + this.chaseCameraControls.enabled = true; + + if (this.camera == this.chaseCamera) + this._resetChaseCamera(); + else + this.camera = this.chaseCamera; + + break; + case "topDown": + this.freeCameraControls.enabled = false; + this.chaseCameraControls.enabled = false; + this.topDownControls.enabled = true; + + if (this.camera == this.topDownCamera) + this._resetTopDownCamera(); + else + this.camera = this.topDownCamera; + + break; + default: + console.log(`Unknown camera mode: ${mode}`); + return; + } + + for (const c in this.cameraButtons) { + const classes = this.cameraButtons[c].classList; + if (c == mode) { + classes.remove('is-outlined'); + classes.add('is-selected'); + } else { + classes.add('is-outlined'); + classes.remove('is-selected'); + } + } + } + + switchTo2D() { + this.switchTo2DButton.classList.remove('is-outlined'); + this.switchTo2DButton.classList.add('is-selected'); + this.switchTo3DButton.classList.add('is-outlined'); + this.switchTo3DButton.classList.remove('is-selected'); + + this.chaseCamera.layers.enable(2); + this.topDownCamera.layers.enable(2); + this.freeCamera.layers.enable(2); + this.chaseCamera.layers.disable(3); + this.topDownCamera.layers.disable(3); + this.freeCamera.layers.disable(3); + } + + switchTo3D() { + this.switchTo3DButton.classList.remove('is-outlined'); + this.switchTo3DButton.classList.add('is-selected'); + this.switchTo2DButton.classList.add('is-outlined'); + this.switchTo2DButton.classList.remove('is-selected'); + + this.chaseCamera.layers.enable(3); + this.topDownCamera.layers.enable(3); + this.freeCamera.layers.enable(3); + this.chaseCamera.layers.disable(2); + this.topDownCamera.layers.disable(2); + this.freeCamera.layers.disable(2); + } + + hideWelcomeModal() { + this.welcomeModal.classList.remove('is-active'); + window.localStorage.setItem(WELCOME_MODAL_KEY, 'hide'); + } + + showPlannerUnavailable(show) { + const message = document.getElementById("planner-unavailable-message"); + if (show) { + message.classList.add('is-active'); + this.autonomousModeButton.classList.add('is-loading'); + } else { + message.classList.remove('is-active'); + this.autonomousModeButton.classList.remove('is-loading'); + } + } + + setHideCollisionMessageOnClickOutside() { + if (!this.collisionMessage.contains(event.target)) { + this.collisionMessage.classList.remove('is-active'); + } + if (!this.successMessage.contains(event.target)) { + this.successMessage.classList.remove('is-active'); + } + } + + startPlanner(pose, station) { + this.plannerReady = false; + this.lastPlanRequestTime = performance.now(); + + // In order to create a stable trajectory between successive planning + // cycles, we must compensate for the latency between when a planning cycle + // starts and when it ends. The average planning time is used to forward + // simulate the vehicle to the pose it is expected to have when the + // planning actually finishes. + + let predictedPose = pose; + let predictedStation = station; + let startTime = this.simulatedTime; + + if (!this.plannerReset && !this.paused && this.autonomousCarController && this.carControllerMode == 'autonomous') { + const latency = this.averagePlanTime.average; + predictedPose = this.autonomousCarController.predictPoseAfterTime(pose, latency); + predictedStation = this.editor.lanePath.stationLatitudeFromPosition(predictedPose.pos, this.aroundAnchorIndex)[0]; + startTime += latency; + } + + const reset = this.plannerReset; + this.plannerReset = false; + + this.lastPlanParams = { + type: 'plan', + config: Object.assign({}, this.pathPlannerConfigEditor.config, { speedLimit: this.editor.speedLimit, lanePreference: this.editor.lanePreference }), + vehiclePose: predictedPose, + vehicleStation: predictedStation, + lanePath: this.editor.lanePath, + startTime: startTime, + staticObstacles: this.staticObstacles, + dynamicObstacles: this.dynamicObstacles.filter(o => o.positionAtTime(startTime).x >= 0), + reset: reset + }; + + this.pathPlannerWorker.postMessage(this.lastPlanParams); + } + + receivePlannedPath(event) { + if (event.data.error) { + if (event.data.error === "planner_unavailable" && !this.paused) { + this.showPlannerUnavailable(true); + } + //document.getElementById('planner-error').classList.remove('is-hidden') + return; + } + + this.showPlannerUnavailable(false); + + this.latestPlanTimestamp = performance.now(); + + if (this.waitingForFirstPlan && !this.plannerReset) { + this.waitingForFirstPlan = false; + this.autonomousModeButton.classList.remove('is-loading'); + this.playScenario(); + } + + if (this.editor.enabled) return; + + const { fromVehicleParams, vehiclePose, vehicleStation, latticeStartStation, config, dynamicObstacleGrid } = event.data; + let { path, fromVehicleSegment } = event.data; + + const planningDuration = Math.min((this.latestPlanTimestamp - this.lastPlanRequestTime) / 1000, 0.3); + this.averagePlanTime.addSample(planningDuration); + this.plannerReady = true; + + if (this.plannerReset) return; + + if (this.plannedPathGroup) + this.scene.remove(this.plannedPathGroup); + this.plannedPathGroup = new THREE.Group(); + this.scene.add(this.plannedPathGroup); + + const circleGeom = new THREE.CircleGeometry(0.1, 32); + const circleMat = new THREE.MeshBasicMaterial({ color: 0x00ff80, transparent: true, opacity: 0.7 }); + + if (latticeStartStation) { + const lattice = new RoadLattice(this.editor.lanePath, latticeStartStation, config); + lattice.lattice.forEach(cells => { + cells.forEach(c => { + const circle = new THREE.Mesh(circleGeom, circleMat); + circle.position.set(c.pos.x, 0, c.pos.y); + circle.rotation.x = -Math.PI / 2; + this.plannedPathGroup.add(circle); + }); + }); + } + + // TODO: clear this up or just remove it + if (false && dynamicObstacleGrid) { + const dynamicGridTex = new THREE.DataTexture(dynamicObstacleGrid.data, dynamicObstacleGrid.width, dynamicObstacleGrid.height, THREE.RGBAFormat, THREE.FloatType); + dynamicGridTex.flipY = true; + dynamicGridTex.needsUpdate = true; + + const [gridStart] = this.editor.lanePath.sampleStations(vehicleStation, 1, 0); + if (gridStart) { + const dynamicGridGeom = new THREE.PlaneGeometry(dynamicObstacleGrid.width * config.slGridCellSize, dynamicObstacleGrid.height * config.slGridCellSize); + const dynamicGridMat = new THREE.MeshBasicMaterial({ map: dynamicGridTex, depthTest: false, transparent: true, opacity: 0.5 }); + const dynamicGridObj = new THREE.Mesh(dynamicGridGeom, dynamicGridMat); + dynamicGridObj.rotation.x = -Math.PI / 2; + dynamicGridObj.rotation.z = -gridStart.rot; + const offset = THREE.Vector2.fromAngle(gridStart.rot).multiplyScalar(dynamicObstacleGrid.width * config.slGridCellSize / 2 - config.spatialHorizon / config.lattice.numStations); + dynamicGridObj.position.set(gridStart.pos.x + offset.x, 0, gridStart.pos.y + offset.y); + + this.plannedPathGroup.add(dynamicGridObj); + } + } + + if (path === null) { + this.autonomousCarController = null; + return; + } + + if (fromVehicleParams.type == 'cubic') { + const start = this.car.pose; + const end = fromVehicleSegment[fromVehicleSegment.length - 1]; + + const pathBuilder = new CubicPath(start, end, fromVehicleParams.params); + + if (pathBuilder.optimize()) { + fromVehicleSegment = pathBuilder.buildPath(Math.ceil(pathBuilder.params.sG / 0.25)); + + const prevVelocitySq = this.car.velocity * this.car.velocity; + const accel = (end.velocity * end.velocity - prevVelocitySq) / 2 / pathBuilder.params.sG; + const ds = pathBuilder.params.sG / (fromVehicleSegment.length - 1); + let s = 0; + + for (let p = 0; p < fromVehicleSegment.length; p++) { + fromVehicleSegment[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq); + fromVehicleSegment[p].acceleration = accel; + s += ds; + } + } + } + + if (fromVehicleSegment.length > 0) { + path = fromVehicleSegment.concat(path); + } + + path.forEach(p => Object.setPrototypeOf(p.pos, THREE.Vector2.prototype)); + const followPath = new Path(path); + + if (this.autonomousCarController) + this.autonomousCarController.replacePath(followPath); + else + this.autonomousCarController = new FollowController(followPath, this.car); + + const pathGeometry = new THREE.Geometry(); + pathGeometry.setFromPoints(path.map(p => new THREE.Vector3(p.pos.x, 0, p.pos.y))); + const pathLine = new MeshLine(); + pathLine.setGeometry(pathGeometry); + + const color = fromVehicleParams.type == 'cubic' ? new THREE.Color(0xff8800) : new THREE.Color(0xffff40); + const pathObject = new THREE.Mesh( + pathLine.geometry, + new MeshLineMaterial({ + color: color, + lineWidth: 0.15, + resolution: new THREE.Vector2(this.renderer.domElement.clientWidth, this.renderer.domElement.clientHeight) + }) + ); + pathObject.renderOrder = 1; + this.plannedPathGroup.add(pathObject); + } + + _hasCarStaticObstacleCollision(carRectangle) { + for (const obstacle of this.staticObstacles) { + const obstacleRectangle = { + x: obstacle.pos.x, + y: obstacle.pos.y, + width: obstacle.width, + height: obstacle.height, + angle: obstacle.rot, + }; + if (areRectanglesColliding(carRectangle, obstacleRectangle)) { + return true; + } + } + } + + _hasCarDynamicObstacleCollision(carRectangle) { + for (const obstacle of this.dynamicObstaclesGroup.children) { + const positoin_at_time = obstacle.position + const obstacleRectangle = { + x: positoin_at_time.x, + y: positoin_at_time.z, + width: obstacle.size.w + 0.4, // 30 cm is collision buffer + height: obstacle.size.h + 0.4, + angle: obstacle.rotation.y, + }; + if (areRectanglesColliding(carRectangle, obstacleRectangle)) { + return true; + } + } + } + + _hasCarOutOfRoadCollision(carRectangle) { + for (const left_boundary of this.editor.lanePath.leftBoundaries) { + if (checkRectanglePolylineIntersection(carRectangle, left_boundary)) { + return true; + } + } + + for (const right_boundary of this.editor.lanePath.rightBoundaries) { + if (checkRectanglePolylineIntersection(carRectangle, right_boundary)) { + return true; + } + } + + return false; + } + + hasAnyCollisions() { + const carRectangle = { + x: this.car.position.x, + y: this.car.position.y, + height: Car.HALF_CAR_WIDTH * 2, + width: Car.HALF_CAR_LENGTH * 2, + angle: this.car.pose.rot, + }; + + if (this._hasCarStaticObstacleCollision(carRectangle)) { + return "Collision with static object"; + } + if (this._hasCarDynamicObstacleCollision(carRectangle)) { + return "Collision with bot"; + } + if (this._hasCarOutOfRoadCollision(carRectangle)) { + return "Out of road"; + } + + return null; + } + + checkScenarioCompletion() { + return this.carStation >= this.editor.lanePath.arcLength - 5.0; + } + + step(timestamp) { + if (this.prevTimestamp == null) { + this.prevTimestamp = timestamp; + requestAnimationFrame(this.step.bind(this)); + return; + } + + // plan is outdated, should pause simulation + const planWaitingThreshold = 0.3; // path expected to be updated once in 300ms + const timeSinceLastPlanUpdate = + this.latestPlanTimestamp != null ? (performance.now() - this.latestPlanTimestamp) / 1000.0 : 0; // in ms + if (!this.editor.enabled && + (this.waitingForFirstPlan || (!this.paused && timeSinceLastPlanUpdate > planWaitingThreshold))) { + this.showPlannerUnavailable(true); + this.prevTimestamp = timestamp; + } + const dt = (timestamp - this.prevTimestamp) / 1000; + + this.editor.update(); + + // skip simulation when dt is not in valid expected range + if (!this.editor.enabled && !this.paused && dt > 1e-6 && dt < 0.5) { + this.showPlannerUnavailable(false); + + this.simulatedTime += dt; + + const prevCarPosition = this.car.position; + const prevCarRotation = this.car.rotation; + + const manualControls = this.manualCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt); + if (manualControls.steer != 0 || manualControls.brake != 0 || manualControls.gas != 0) + this.enableManualMode(); + + let autonomousControls = { steer: 0, brake: 0, gas: 0}; + if (this.autonomousCarController) + autonomousControls = this.autonomousCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt, this.carControllerMode == 'autonomous') ; + else if (this.autonomousCarController === null) + autonomousControls = { steer: 0, brake: 1, gas: 0 }; + + const controls = this.carControllerMode == 'autonomous' ? autonomousControls : manualControls; + + this.car.update(controls, dt); + this.physics.step(dt); + + this.updateDynamicObjects(this.simulatedTime); + + const carPosition = this.car.position; + const carRotation = this.car.rotation; + const carRearAxle = this.car.rearAxlePosition; + const carVelocity = this.car.velocity; + + const positionOffset = { x: carPosition.x - prevCarPosition.x, y: 0, z: carPosition.y - prevCarPosition.y }; + this.chaseCamera.position.add(positionOffset); + this.chaseCameraControls.target.set(carPosition.x, 0, carPosition.y); + this.chaseCameraControls.rotateLeft(carRotation - prevCarRotation); + this.chaseCameraControls.update(); + + this.topDownCamera.position.setX(carPosition.x); + this.topDownCamera.position.setZ(carPosition.y); + this.topDownCamera.rotation.z = -carRotation - Math.PI / 2 + + let latitude = null; + + if (this.editor.lanePath.anchors.length > 1) { + const [s, l, aroundAnchorIndex] = this.editor.lanePath.stationLatitudeFromPosition(carRearAxle, this.aroundAnchorIndex); + this.aroundAnchorIndex = aroundAnchorIndex; + + this.carStation = s; + latitude = l; + } + + const any_collision = this.hasAnyCollisions(); + if (any_collision != null) { + this.pauseScenario(); + this.collisionMessage.classList.add('is-active'); + document.getElementById('collision-message-text').innerText = "Case failed: " + any_collision; + + this.pathPlannerWorker.postMessage({ + type: 'notify_case_status', + status: {status: "failed", reason: any_collision} + }); + + } else if (this.checkScenarioCompletion()) { + this.pauseScenario(); + this.successMessage.classList.add('is-active'); + + this.pathPlannerWorker.postMessage({ + type: 'notify_case_status', + status: {status: "completed"} + }); + } + + this.dashboard.update( + controls, + carVelocity, + this.carStation, + latitude, + this.simulatedTime, + this.averagePlanTime.average); + } + + if (!this.editor.enabled && this.plannerReady) { + this.startPlanner(this.car.pose, this.carStation || 0); + this.dashboard.updatePlanTime(this.averagePlanTime.average); + } else if (!this.plannerReady) { + this.dashboard.updatePlanTime(timeSinceLastPlanUpdate); + } + + this.frameCounter++; + this.fpsTime += dt; + if (this.fpsTime >= 1) { + this.fps = this.frameCounter / this.fpsTime; + this.frameCounter = 0; + this.fpsTime = 0; + this.fpsBox.textContent = this.fps.toFixed(1); + } + + this.renderer.render(this.scene, this.camera); + + this.prevTimestamp = timestamp; + + requestAnimationFrame(this.step.bind(this)); + } +} diff --git a/seminar06-planning/simulator/js/Utils.js b/seminar06-planning/simulator/js/Utils.js new file mode 100644 index 0000000..9ddcbd9 --- /dev/null +++ b/seminar06-planning/simulator/js/Utils.js @@ -0,0 +1,151 @@ +Math.clamp = (number, min, max) => Math.max(min, Math.min(number, max)); + +Math.wrapAngle = (angle) => { + angle = angle % (Math.PI * 2); + if (angle <= -Math.PI) return angle + Math.PI * 2; + else if (angle > Math.PI) return angle - Math.PI * 2; + else return angle; +} + +THREE.Vector2.fromAngle = (angle) => new THREE.Vector2(Math.cos(angle), Math.sin(angle)); + +THREE.Curve.prototype.getCurvatureAt = function(u) { + let t2 = this.getUtoTmapping(u); + + const delta = 0.0001; + let t1 = t2 - delta; + let t3 = t2 + delta; + + if (t1 < 0) { + t1 = 0; + t2 = delta; + t3 = 2 * delta; + } + + if (t3 > 1) { + t3 = 1; + t2 = 1 - delta; + t1 = 1 - 2 * delta; + } + + const p1 = this.getPoint(t1); + const p2 = this.getPoint(t2); + const p3 = this.getPoint(t3); + + return (Math.atan2(p3.y - p2.y, p3.x - p2.x) - Math.atan2(p2.y - p1.y, p2.x - p1.x)) / p2.distanceTo(p1); +}; + + +function getOBBVertices(cx, cy, width, height, angle) { + const hw = width / 2; // half width + const hh = height / 2; // half height + const cos = Math.cos(angle); + const sin = Math.sin(angle); + + return [ + // Top-left + { x: cx - hw * cos + hh * sin, y: cy - hw * sin - hh * cos }, + // Top-right + { x: cx + hw * cos + hh * sin, y: cy + hw * sin - hh * cos }, + // Bottom-right + { x: cx + hw * cos - hh * sin, y: cy + hw * sin + hh * cos }, + // Bottom-left + { x: cx - hw * cos - hh * sin, y: cy - hw * sin + hh * cos } + ]; +} + +function getOOBBAxes(vertices) { + const axes = []; + for (let i = 0; i < vertices.length; i++) { + const p1 = vertices[i]; + const p2 = vertices[(i + 1) % vertices.length]; // Next vertex + const edge = { x: p1.x - p2.x, y: p1.y - p2.y }; // Get edge vector + const normal = { x: -edge.y, y: edge.x }; // Get normal (perpendicular) vector + const length = Math.sqrt(normal.x * normal.x + normal.y * normal.y); + axes.push({ x: normal.x / length, y: normal.y / length }); // Normalize vector + } + return axes; +} + +function projectOnAxis(vertices, axis) { + let min = Infinity; + let max = -Infinity; + for (const vertex of vertices) { + let projection = vertex.x * axis.x + vertex.y * axis.y; + min = Math.min(min, projection); + max = Math.max(max, projection); + } + return { min, max }; +} + +function segmentsOverlaps(projection1, projection2) { + return projection1.max >= projection2.min && projection2.max >= projection1.min; +} + +function areRectanglesColliding(rect1, rect2) { + const verticesA = getOBBVertices(rect1.x, rect1.y, rect1.width, rect1.height, rect1.angle); + const verticesB = getOBBVertices(rect2.x, rect2.y, rect2.width, rect2.height, rect2.angle); + + const axesA = getOOBBAxes(verticesA); + const axesB = getOOBBAxes(verticesB); + const axes = axesA.concat(axesB); + + for (const axis of axes) { + const projectionA = projectOnAxis(verticesA, axis); + const projectionB = projectOnAxis(verticesB, axis); + if (!segmentsOverlaps(projectionA, projectionB)) { + return false; // Found a separating axis, no collision + } + } + + return true; // No separating axis found, rectangles intersect +} + +function checkRectanglePolylineIntersection(rect, polylinePoints) { + const rectanglePoints = getOBBVertices(rect.x, rect.y, rect.width, rect.height, rect.angle) + + // Transform rectangle points into array of lines + const rectangleLines = []; + for (let i = 0; i < rectanglePoints.length; i++) { + rectangleLines.push([ + rectanglePoints[i], + rectanglePoints[(i + 1) % rectanglePoints.length] + ]); + } + + // Check each polyline segment for intersection with each rectangle line + for (let i = 0; i < polylinePoints.length - 1; i++) { + const polylineSegment = [ + polylinePoints[i], + polylinePoints[i + 1] + ]; + + for (const rectLine of rectangleLines) { + if (intersectSegment(rectLine[0], rectLine[1], polylineSegment[0], polylineSegment[1])) { + return true; // Found an intersection + } + } + } + + // No intersections found + return false; +} + +// Helper function to detect intersection between two line segments +function intersectSegment(p0, p1, p2, p3) { + let s1_x, s1_y, s2_x, s2_y; + s1_x = p1.x - p0.x; s1_y = p1.y - p0.y; + s2_x = p3.x - p2.x; s2_y = p3.y - p2.y; + + let s, t; + s = (-s1_y * (p0.x - p2.x) + s1_x * (p0.y - p2.y)) / (-s2_x * s1_y + s1_x * s2_y); + t = ( s2_x * (p0.y - p2.y) - s2_y * (p0.x - p2.x)) / (-s2_x * s1_y + s1_x * s2_y); + + // Collision detected + if (s >= 0 && s <= 1 && t >= 0 && t <= 1) { + // Intersection point is p0 + t * s1 + return true; + } + + return false; // No collision +} diff --git a/seminar06-planning/simulator/js/autonomy/DynamicObstacle.js b/seminar06-planning/simulator/js/autonomy/DynamicObstacle.js new file mode 100644 index 0000000..ddf5364 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/DynamicObstacle.js @@ -0,0 +1,99 @@ +// Half width and half height +const VEHICLE_SIZE = { w: 2.5, h: 1 }; +const CYCLIST_SIZE = { w: 1.2, h: 0.6 }; +const PEDESTRIAN_SIZE = { w: 0.6, h: 0.6 }; + +export default class DynamicObstacle { + static hydrate(obj) { + Object.setPrototypeOf(obj, DynamicObstacle.prototype); + Object.setPrototypeOf(obj.startPos, THREE.Vector2.prototype); + Object.setPrototypeOf(obj.velocity, THREE.Vector2.prototype); + } + + constructor(type, startPos, velocity, parallel) { + this.type = type; + this.startPos = startPos; + this.velocity = velocity; + this.parallel = parallel; + + switch (type) { + case 'cyclist': + this.size = Object.assign({}, CYCLIST_SIZE); + break; + + case 'pedestrian': + this.size = Object.assign({}, PEDESTRIAN_SIZE); + break; + + default: + this.size = Object.assign({}, VEHICLE_SIZE); + } + + if (!parallel) + [this.size.w, this.size.h] = [this.size.h, this.size.w]; + } + + positionAtTime(time) { + return this.velocity.clone().multiplyScalar(time).add(this.startPos); + } + + positionsInTimeRange(startTime, endTime, numFrames) { + const dt = (endTime - startTime) / numFrames; + const positions = []; + let time = startTime; + + for (let i = 0; i <= numFrames; i++) { + positions.push(this.positionAtTime(time)); + time += dt; + } + + return positions; + } + + verticesInTimeRange(startTime, endTime, config) { + const positions = this.positionsInTimeRange(startTime, endTime, config.numDynamicSubframes); + const vertices = []; + + // Hazard dilation (drawn behind, z = 0.75) + const hazardHalfWidth = this.size.w + config.dynamicHazardDilationS + config.collisionDilationS; + const hazardHalfHeight = this.size.h + config.dynamicHazardDilationL + config.collisionDilationL; + + positions.forEach(p => { + const v1 = [-hazardHalfWidth + p.x, hazardHalfHeight + p.y]; + const v2 = [hazardHalfWidth + p.x, hazardHalfHeight + p.y]; + const v3 = [hazardHalfWidth + p.x, -hazardHalfHeight + p.y]; + const v4 = [-hazardHalfWidth + p.x, -hazardHalfHeight + p.y]; + + vertices.push( + v1[0], v1[1], 0.75, + v2[0], v2[1], 0.75, + v3[0], v3[1], 0.75, + v3[0], v3[1], 0.75, + v4[0], v4[1], 0.75, + v1[0], v1[1], 0.75 + ); + }); + + // Collision dilation (drawn in front, z = 0.25) + const collisionHalfWidth = this.size.w + config.collisionDilationS; + const collisionHalfHeight = this.size.h + config.collisionDilationL; + + positions.forEach(p => { + const v1 = [-collisionHalfWidth + p.x, collisionHalfHeight + p.y]; + const v2 = [collisionHalfWidth + p.x, collisionHalfHeight + p.y]; + const v3 = [collisionHalfWidth + p.x, -collisionHalfHeight + p.y]; + const v4 = [-collisionHalfWidth + p.x, -collisionHalfHeight + p.y]; + + vertices.push( + v1[0], v1[1], 0.25, + v2[0], v2[1], 0.25, + v3[0], v3[1], 0.25, + v3[0], v3[1], 0.25, + v4[0], v4[1], 0.25, + v1[0], v1[1], 0.25 + ); + }); + + return vertices; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/LanePath.js b/seminar06-planning/simulator/js/autonomy/LanePath.js new file mode 100644 index 0000000..f75a0d0 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/LanePath.js @@ -0,0 +1,307 @@ +const halfLaneWidth = 3.7; + +const centerlineGeometry = new THREE.Geometry(); +const leftBoundaryGeometry = new THREE.Geometry(); +const rightBoundaryGeometry = new THREE.Geometry(); + +export default class LanePath { + static hydrate(obj) { + Object.setPrototypeOf(obj, LanePath.prototype); + } + + constructor() { + this.anchors = []; + this.centerlines = []; + this.sampleLengths = []; + this.arcLengths = []; + this.leftBoundaries = []; + this.rightBoundaries = []; + } + + get centerline() { + return [].concat(...this.centerlines); + } + + get leftBoundary() { + return [].concat(...this.leftBoundaries); + } + + get rightBoundary() { + return [].concat(...this.rightBoundaries); + } + + get arcLength() { + return this.arcLengths.reduce((sum, l) => sum + l, 0); + } + + sampleStations(startStation, num, interval) { + const samples = []; + let anchorIndex = 0; + let sampleIndex = 0; + let totalLength = 0; + let nextStation = startStation; + + while (totalLength + this.arcLengths[anchorIndex] < nextStation) { + totalLength += this.arcLengths[anchorIndex]; + + if (++anchorIndex >= this.arcLengths.length) + return samples; + } + + for (let i = 0; i < num; i++) { + let length = this.sampleLengths[anchorIndex][sampleIndex]; + while (totalLength + length < nextStation) { + totalLength += length; + + if (++sampleIndex >= this.sampleLengths[anchorIndex].length) { + sampleIndex = 0; + + if (++anchorIndex >= this.sampleLengths.length) + return samples; + } + + length = this.sampleLengths[anchorIndex][sampleIndex]; + } + + const [p0, p1, p2, p3] = this.anchorsForSplineIndex(anchorIndex); + const weight = (sampleIndex + (nextStation - totalLength) / length) / this.sampleLengths[anchorIndex].length; + const pos = catmullRomVec(weight, p0, p1, p2, p3); + const tangent = tangentAt(weight, p0, p1, p2, p3); + const rot = Math.atan2(tangent.y, tangent.x); + const curv = curvatureAt(weight, p0, p1, p2, p3); + + samples.push({ pos, rot, curv }); + nextStation += interval; + } + + return samples; + } + + stationLatitudeFromPosition(position, aroundAnchorIndex = null) { + const [anchorIndex, sampleIndex, sampleStation, prevSampleStation] = this._findClosestSample(position, aroundAnchorIndex); + + if (anchorIndex === undefined) return [0, 0, 0]; + + let prevPoint; + let nextPoint; + let prevStation; + let nextStation; + + if (anchorIndex == 0 && sampleIndex == 0) { + prevPoint = this.centerlines[anchorIndex][sampleIndex]; + nextPoint = this.centerlines[anchorIndex][sampleIndex + 1]; + prevStation = 0; + nextStation = this.sampleLengths[anchorIndex][sampleIndex]; + } else if (anchorIndex == this.centerlines.length - 1 && sampleIndex == this.centerlines[anchorIndex].length - 1) { + prevPoint = this.centerlines[anchorIndex][sampleIndex - 1]; + nextPoint = this.centerlines[anchorIndex][sampleIndex]; + prevStation = prevSampleStation; + nextStation = sampleStation; + } else { + prevPoint = sampleIndex == 0 ? this.centerlines[anchorIndex - 1][this.centerlines[anchorIndex - 1].length - 1] : this.centerlines[anchorIndex][sampleIndex - 1]; + nextPoint = sampleIndex == this.centerlines[anchorIndex].length - 1 ? this.centerlines[anchorIndex + 1][0] : this.centerlines[anchorIndex][sampleIndex + 1]; + + const possibleNext = this.centerlines[anchorIndex][sampleIndex]; + const possibleProgress = position.clone().sub(prevPoint).dot(possibleNext.clone().sub(prevPoint)) / prevPoint.distanceToSquared(possibleNext); + + if (possibleProgress < 1) { + nextPoint = possibleNext; + prevStation = prevSampleStation; + nextStation = sampleStation; + } else { + prevPoint = possibleNext; + prevStation = sampleStation; + nextStation = sampleStation + this.sampleLengths[anchorIndex][sampleIndex]; + } + } + + const progress = Math.clamp(position.clone().sub(prevPoint).dot(nextPoint.clone().sub(prevPoint)) / prevPoint.distanceToSquared(nextPoint), 0, 1); + const projectedPosition = nextPoint.clone().sub(prevPoint).multiplyScalar(progress).add(prevPoint); + + const station = prevStation + (nextStation - prevStation) * progress; + const latitude = Math.sign((nextPoint.x - prevPoint.x) * (position.y - prevPoint.y) - (nextPoint.y - prevPoint.y) * (position.x - prevPoint.x)) * position.distanceTo(projectedPosition); + + return [station, latitude, anchorIndex]; + } + + _findClosestSample(position, aroundAnchorIndex = null) { + let closest = Number.POSITIVE_INFINITY; + let bestAnchorIndex; + let bestSampleIndex; + let bestStation; + let bestPrevStation; + + let currStation = 0; + let prevStation = 0; + + let startAnchorIndex = 0; + let endAnchorIndex = this.centerlines.length - 1; + + if (aroundAnchorIndex !== null) { + startAnchorIndex = Math.max(0, aroundAnchorIndex - 2); + endAnchorIndex = Math.min(this.centerlines.length - 1, aroundAnchorIndex + 2); + } + + if (startAnchorIndex > 0) { + for (let anchorIndex = 0; anchorIndex < startAnchorIndex; anchorIndex++) { + currStation += this.arcLengths[anchorIndex]; + } + + prevStation = currStation - this.sampleLengths[startAnchorIndex - 1][this.sampleLengths[startAnchorIndex - 1].length - 1]; + } + + for (let anchorIndex = startAnchorIndex; anchorIndex <= endAnchorIndex; anchorIndex++) { + const centerline = this.centerlines[anchorIndex]; + for (let sampleIndex = 0; sampleIndex < centerline.length; sampleIndex++) { + const distSq = position.distanceToSquared(centerline[sampleIndex]); + if (distSq < closest) { + closest = distSq; + bestAnchorIndex = anchorIndex; + bestSampleIndex = sampleIndex; + bestStation = currStation; + bestPrevStation = prevStation; + } + + prevStation = currStation; + currStation += this.sampleLengths[anchorIndex][sampleIndex]; + } + } + + return [bestAnchorIndex, bestSampleIndex, bestStation, bestPrevStation]; + } + + addAnchor(position, resample = true) { + const index = this.anchors.push(position) - 1; + + if (resample) { + for (let i = index - 2; i < index; i++) + this.resample(i); + } + } + + updateAnchor(index, position) { + this.anchors[index] = position; + + for (let i = index - 2; i <= index + 1; i++) + this.resample(i); + } + + removeAnchor(index) { + if (index < 0 || index >= this.anchors.length) return; + + this.anchors.splice(index, 1); + + const segmentIndex = index < this.anchors.length ? index : index - 1; + this.centerlines.splice(segmentIndex, 1); + this.sampleLengths.splice(segmentIndex, 1); + this.leftBoundaries.splice(segmentIndex, 1); + this.rightBoundaries.splice(segmentIndex, 1); + this.arcLengths.splice(segmentIndex, 1); + + for (let i = segmentIndex - 2; i <= segmentIndex; i++) + this.resample(i); + } + + resample(index) { + if (index < 0 || index > this.anchors.length - 2) return; + + const [p0, p1, p2, p3] = this.anchorsForSplineIndex(index); + const points = []; + const lengths = []; + const leftBoundary = []; + const rightBoundary = []; + let prevPoint = null; + + const pointsPerSegment = Math.max(10, Math.ceil(p1.distanceTo(p2) / 1)); + const numPoints = index == this.anchors.length - 2 ? pointsPerSegment + 1 : pointsPerSegment; + + for (let i = 0; i < numPoints; i++) { + const t = i / pointsPerSegment; + const point = catmullRomVec(t, p0, p1, p2, p3); + points.push(point); + + if (prevPoint != null) + lengths.push(prevPoint.distanceTo(point)); + prevPoint = point; + + const tangent = tangentAt(t, p0, p1, p2, p3); + const normal = new THREE.Vector2(-tangent.y, tangent.x); + + leftBoundary.push(normal.clone().multiplyScalar(-halfLaneWidth).add(point)); + rightBoundary.push(normal.clone().multiplyScalar(halfLaneWidth).add(point)); + } + + lengths.push(prevPoint.distanceTo(p2)); + + this.centerlines[index] = points; + this.sampleLengths[index] = lengths; + this.leftBoundaries[index] = leftBoundary; + this.rightBoundaries[index] = rightBoundary; + this.arcLengths[index] = lengths.reduce((sum, l) => sum + l, 0); + } + + resampleAll() { + for (let i = 0; i < this.anchors.length; i++) + this.resample(i); + } + + anchorsForSplineIndex(index) { + let p; + if (index == 0) + p = [this.anchors[0]].concat(this.anchors.slice(0, 3)); + else + p = this.anchors.slice(index - 1, index + 3); + + if (p[3] === undefined) + p[3] = p[2]; + + return p; + } +} + +function catmullRom(t, p0, p1, p2, p3) { + const v0 = (p2 - p0) * 0.5; + const v1 = (p3 - p1) * 0.5; + const t2 = t * t; + const t3 = t * t2; + return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1; +} + +function catmullRomVec(t, p0, p1, p2, p3) { + return new THREE.Vector2(catmullRom(t, p0.x, p1.x, p2.x, p3.x), catmullRom(t, p0.y, p1.y, p2.y, p3.y)); +} + +function tangentAt(t, p0, p1, p2, p3) { + const delta = 0.0001; + let t1 = t - delta; + let t2 = t + delta; + + if (t1 < 0) t1 = 0; + if (t2 > 1) t2 = 1; + + const prev = catmullRomVec(t1, p0, p1, p2, p3); + const next = catmullRomVec(t2, p0, p1, p2, p3); + + return next.sub(prev).normalize(); +} + +function curvatureAt(t2, p0, p1, p2, p3) { + const delta = 0.0001; + + // If we're estimating curvature at one of the endpoints of the spline, + // slightly shift it inwards to avoid infinite curvature. + if (t2 == 0) t2 = delta; + if (t2 == 1) t2 = 1 - delta; + + let t1 = t2 - delta; + let t3 = t2 + delta; + + if (t1 < 0) t1 = 0; + if (t3 > 1) t3 = 1; + + const pt1 = catmullRomVec(t1, p0, p1, p2, p3); + const pt2 = catmullRomVec(t2, p0, p1, p2, p3); + const pt3 = catmullRomVec(t3, p0, p1, p2, p3); + + return (Math.atan2(pt3.y - pt2.y, pt3.x - pt2.x) - Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x)) / pt2.distanceTo(pt1); +} diff --git a/seminar06-planning/simulator/js/autonomy/MovingAverage.js b/seminar06-planning/simulator/js/autonomy/MovingAverage.js new file mode 100644 index 0000000..a3da5ca --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/MovingAverage.js @@ -0,0 +1,25 @@ +export default class MovingAverage { + constructor(maxSamples) { + this.samples = new Array(maxSamples); + this.numSamples = 0; + this.nextIndex = 0; + this.average = null; + } + + addSample(sample) { + this.samples[this.nextIndex++] = sample; + this.nextIndex = this.nextIndex % this.samples.length; + this.numSamples = Math.min(this.numSamples + 1, this.samples.length); + + const k = 2 / (this.numSamples + 1); + let curr = this.nextIndex % this.numSamples; + let newAverage = this.samples[curr]; + + for (let i = 1; i < this.numSamples; i++) { + curr = (curr + 1) % this.numSamples; + newAverage = this.samples[curr] * k + newAverage * (1 - k); + } + + this.average = newAverage; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/Path.js b/seminar06-planning/simulator/js/autonomy/Path.js new file mode 100644 index 0000000..11b4757 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/Path.js @@ -0,0 +1,60 @@ +import Car from "../physics/Car.js" + +// input pose: { pos: Vector2 [, rot: radians] } +// pose: { pos: Vector2, frontPos: Vector2, fakePos: Vector2, rot: radians } +export default class Path { + constructor(poses, startRotation = 0, goalRotation = 0) { + this.poses = poses; + + for (let i = 0; i < poses.length; i++) { + const pose = poses[i]; + + if (pose.rot === undefined || pose.rot == null) { + let rot; + + if (i == 0) { + rot = startRotation; + } else if (i == poses.length - 1) { + rot = goalRotation; + } else { + const prev = poses[i - 1].pos; + const next = poses[i + 1].pos; + rot = Math.atan2(next.y - prev.y, next.x - prev.x); + } + + pose.rot = rot; + } + + if (pose.curv === undefined || pose.curv == null) { + if (i > 0 && i < poses.length - 1) { + const prev = poses[i - 1].pos; + const cur = poses[i].pos; + const next = poses[i + 1].pos; + + const dir1 = { x: cur.x - prev.x, y: cur.y - prev.y }; + const dir2 = { x: next.x - cur.x, y: next.y - cur.y }; + + const angle1 = Math.atan2(dir1.y, dir1.x); + const angle2 = Math.atan2(dir2.y, dir2.x); + + // Calculate the angular difference in a way that properly handles the wrap-around from -π to π + let deltaAngle = angle2 - angle1; + // Normalize the angle difference to be within the range [-π, π] + deltaAngle = (deltaAngle + Math.PI) % (2 * Math.PI) - Math.PI; + + // Assuming uniform segment lengths, the curvature (inverse radius of curvature) can be + // approximated as the change in angle. For non-uniform segment lengths, include arc length in calculation + const curvature = Math.abs(deltaAngle); // Using absolute value of angle difference + + pose.curv = curvature; + } else { + // Assign zero curvature for start and end points or handle as needed + pose.curv = 0; + } + } + + pose.frontPos = Car.getFrontAxlePosition(pose.pos, pose.rot); + pose.fakePos = Car.getFakeAxlePosition(pose.pos, pose.rot); + } + } +} diff --git a/seminar06-planning/simulator/js/autonomy/StaticObstacle.js b/seminar06-planning/simulator/js/autonomy/StaticObstacle.js new file mode 100644 index 0000000..db8ac07 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/StaticObstacle.js @@ -0,0 +1,58 @@ +export default class StaticObstacle { + static hydrate(obj) { + Object.setPrototypeOf(obj, StaticObstacle.prototype); + Object.setPrototypeOf(obj.pos, THREE.Vector2.prototype); + } + + static fromJSON(json) { + return new StaticObstacle(new THREE.Vector2(json.p[0], json.p[1]), json.r, json.w, json.h); + } + + constructor(pos, rot, width, height) { + this.pos = pos; + this.rot = rot; + this.width = width; + this.height = height; + + this.updateVertices(); + } + + toJSON() { + const trunc = n => +n.toFixed(5); + + return { + p: [trunc(this.pos.x), trunc(this.pos.y)], + r: trunc(this.rot), + w: trunc(this.width), + h: trunc(this.height) + }; + } + + updateVertices() { + this.vertices = []; + + const cosRot = Math.cos(this.rot); + const sinRot = Math.sin(this.rot); + const halfWidth = this.width / 2; + const halfHeight = this.height / 2; + + const hWcR = halfWidth * cosRot; + const hWsR = halfWidth * sinRot; + const hHcR = halfHeight * cosRot; + const hHsR = halfHeight * sinRot; + + const v1 = [-hWcR - hHsR + this.pos.x, -hWsR + hHcR + this.pos.y]; + const v2 = [-hWcR + hHsR + this.pos.x, -hWsR - hHcR + this.pos.y]; + const v3 = [hWcR + hHsR + this.pos.x, hWsR - hHcR + this.pos.y]; + const v4 = [hWcR - hHsR + this.pos.x, hWsR + hHcR + this.pos.y]; + + this.vertices = [ + v1[0], v1[1], + v2[0], v2[1], + v3[0], v3[1], + v3[0], v3[1], + v4[0], v4[1], + v1[0], v1[1] + ]; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/control/AutonomousController.js b/seminar06-planning/simulator/js/autonomy/control/AutonomousController.js new file mode 100644 index 0000000..0bfdafd --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/control/AutonomousController.js @@ -0,0 +1,181 @@ +import Car from "../../physics/Car.js" + +export default class AutonomousController { + constructor(path) { + this.path = path; + this.nextIndex = 1; + this.prevPhiError = 0; + this.prevVelocity = 0; + } + + reset() { + this.prevVelocity = 0; + } + + replacePath(path) { + this.path = path; + this.nextIndex = 1; + } + + predictPoseAfterTime(currentPose, predictionTime) { + const pathPoses = this.path.poses; + const frontAxlePos = Car.getFrontAxlePosition(currentPose.pos, currentPose.rot); + let [nextIndex, progress] = this.findNextIndex(frontAxlePos); + let currentVelocity = currentPose.velocity; + + if (currentVelocity <= 0.01) return currentPose; + + while (predictionTime > 0) { + const prevPose = pathPoses[nextIndex - 1]; + const nextPose = pathPoses[nextIndex]; + + const segmentDist = nextPose.pos.distanceTo(prevPose.pos); + const distLeft = segmentDist * (1 - progress); + const sumV = currentVelocity + nextPose.velocity; + const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV); + //const timeToNextIndex = distLeft / currentVelocity; + + if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) { + const dist = sumV / 2 * predictionTime; + const newProgress = progress + dist / segmentDist; + + return { + pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos), + rot: prevPose.rot + (nextPose.rot - prevPose.rot) * newProgress, + curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress, + dCurv: 0, + ddCurv: 0, + velocity: nextPose.velocity + } + } + + //currentVelocity = nextPose.velocity; + predictionTime -= timeToNextIndex; + progress = 0; + nextIndex++; + } + } + + control(pose, wheelAngle, velocity, dt) { + const pathPoses = this.path.poses; + const frontAxlePos = Car.getFrontAxlePosition(pose.pos, pose.rot); + const [nextIndex, progress] = this.findNextIndex(frontAxlePos); + this.nextIndex = nextIndex; + + let gas = 0; + let brake = 0; + let phi = 0; // the desired wheel deflection + + if (nextIndex >= pathPoses.length - 1 && progress >= 1) { + gas = 0; + brake = 1; + phi = 0; + } else { + const kp_a = 4; + const kd_a = 0.5; + const kff_a = 0.5; + + const currentAccel = (velocity - this.prevVelocity) / dt; + const prevNextDist = pathPoses[this.nextIndex].pos.distanceTo(pathPoses[this.nextIndex - 1].pos); + const targetVelocity = Math.sqrt(2 * pathPoses[nextIndex].acceleration * prevNextDist * Math.clamp(progress, 0, 1) + pathPoses[this.nextIndex - 1].velocity * pathPoses[this.nextIndex - 1].velocity); + const diffVelocity = targetVelocity - velocity; + const diffAccel = pathPoses[this.nextIndex].acceleration - currentAccel; + const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * pathPoses[this.nextIndex].acceleration; + + if (targetAccel > 0) + gas = Math.min(targetAccel / Car.MAX_GAS_ACCEL, 1); + else + brake = Math.min(-targetAccel / Car.MAX_BRAKE_DECEL, 1); + + this.prevVelocity = velocity; + + const closestFrontPathPos = projectPointOnSegment(frontAxlePos, pathPoses[this.nextIndex - 1].frontPos, pathPoses[this.nextIndex].frontPos)[0]; + + // Determine the desired heading at the specific point on the front path by lerping between prevHeading and nextHeading using progress as the weight + const prevHeading = this.nextIndex > 1 ? pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 2].frontPos).angle() : pathPoses[0].rot; + const nextHeading = this.nextIndex < pathPoses.length - 1 ? pathPoses[nextIndex + 1].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).angle() : pathPoses[pathPoses.length - 1].rot; + const desiredHeading = prevHeading + (nextHeading - prevHeading) * progress; + + // Determine if the front axle is to the left or right of the front path + const pathVec = pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).normalize(); + const zero = new THREE.Vector2(0, 0); + const left = pathVec.clone().rotateAround(zero, Math.PI / 2).add(closestFrontPathPos); + const right = pathVec.clone().rotateAround(zero, -Math.PI / 2).add(closestFrontPathPos); + const dir = frontAxlePos.distanceToSquared(left) < frontAxlePos.distanceToSquared(right) ? -1 : 1; + + const k = 4; + const gain = 0.8; + const crossTrackError = frontAxlePos.distanceTo(closestFrontPathPos); + const headingError = Math.wrapAngle(pose.rot - desiredHeading); + + //phi = -headingError + gain * Math.atan(k * dir * crossTrackError / velocity); + + const curv = pathPoses[nextIndex - 1].curv + (pathPoses[nextIndex].curv - pathPoses[nextIndex - 1].curv) * progress; + + phi = Math.atan(curv * Car.WHEEL_BASE) + gain * Math.atan(k * dir * crossTrackError / Math.max(velocity, 0.01)); + + const checkSteer = Math.clamp((phi - wheelAngle) / dt / Car.MAX_STEER_SPEED, -1, 1); + } + + const phiError = phi - wheelAngle; + /* + const dPhiError = (phiError - this.prevPhiError) / dt; + this.prevPhiError = phiError; + + const steer = Math.clamp(12 * phiError + 0.8 * dPhiError, -1, 1); + */ + + const steer = Math.clamp(phiError / dt / Car.MAX_STEER_SPEED, -1, 1); + + return { gas, brake, steer }; + } + + // Finds the next point the vehicle is approaching and the progress between the prev point and the next point + // Returns [nextPointIndex, progress from (nextPointIndex - 1) to nextPointIndex, {0 - 1}] + findNextIndex(frontAxlePos) { + const pathPoses = this.path.poses; + + // Constrain the search to just a few points surrounding the current nextIndex + // for performance and to avoid problems with a path that crosses itself + const start = Math.max(0, this.nextIndex - 20); + const end = Math.min(pathPoses.length - 1, this.nextIndex + 20); + let closestDistSqr = frontAxlePos.distanceToSquared(pathPoses[start].frontPos); + let closestIndex = start; + + for (let i = start + 1; i < end; i++) { + const distSqr = frontAxlePos.distanceToSquared(pathPoses[i].frontPos); + if (distSqr < closestDistSqr) { + closestDistSqr = distSqr; + closestIndex = i; + } + } + + if (closestIndex == pathPoses.length - 1) { + const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos); + return [closestIndex, progress]; + } else if (closestIndex == 0) { + const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos); + return [closestIndex + 1, progress]; + } else { + // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the frontAxlePos to both + // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint) + // to determine which segment it's closest to. + const [precedingProjection, precedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos); + const [succeedingProjection, succeedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos); + + if (frontAxlePos.distanceToSquared(precedingProjection) < frontAxlePos.distanceToSquared(succeedingProjection)) { + return [closestIndex, precedingProgress]; + } else { + return [closestIndex + 1, succeedingProgress]; + } + } + } +} + +// Returns [pointOnSegment, progressAlongSegment {0 - 1}] +function projectPointOnSegment(point, start, end) { + const distSqr = start.distanceToSquared(end); + //const progress = Math.clamp(point.clone().sub(start).dot(end.clone().sub(start)) / distSqr, 0, 1); + const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr; + return [end.clone().sub(start).multiplyScalar(progress).add(start), progress]; +} diff --git a/seminar06-planning/simulator/js/autonomy/control/FollowController.js b/seminar06-planning/simulator/js/autonomy/control/FollowController.js new file mode 100644 index 0000000..32bde1a --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/control/FollowController.js @@ -0,0 +1,177 @@ +import Car from "../../physics/Car.js" + +export default class FollowController { + constructor(path, car) { + this.path = path; + this.car = car; + this.nextIndex = 1; + this.prevVelocity = 0; + this.prevAccel = 0; + } + + reset() { + this.prevVelocity = 0; + this.prevAccel = 0; + } + + replacePath(path) { + this.path = path; + this.nextIndex = 1; + } + + predictPoseAfterTime(currentPose, predictionTime) { + const pathPoses = this.path.poses; + let [nextIndex, progress] = this.findNextIndex(currentPose.pos); + let currentVelocity = currentPose.velocity; + + if (currentVelocity <= 0.01) return currentPose; + + while (predictionTime > 0) { + const prevPose = pathPoses[nextIndex - 1]; + const nextPose = pathPoses[nextIndex]; + + const segmentDist = nextPose.pos.distanceTo(prevPose.pos); + const distLeft = segmentDist * (1 - progress); + const sumV = (currentVelocity + nextPose.velocity) / 2; + const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV); + + if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) { + const dist = sumV / 2 * predictionTime; + const newProgress = progress + dist / segmentDist; + const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * newProgress); + + const pprevPose = nextIndex - 2 >= 0 ? pathPoses[nextIndex - 2] : prevPose; + const nnextPose = nextIndex + 1 < pathPoses.length ? pathPoses[nextIndex + 1] : nextPose; + + const dCurv = (nextPose.curv - prevPose.curv) / segmentDist; + const dCurvPrev = ((prevPose.curv - pprevPose.curv) / pprevPose.pos.distanceTo(prevPose.pos) + dCurv) / 2; + const dCurvNext = (dCurv + (nnextPose.curv - nextPose.curv) / nextPose.pos.distanceTo(nnextPose.pos)) / 2; + + const ddCurv = (dCurvNext - dCurvPrev) / segmentDist; + + return { + pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos), + rot: newRotation, + curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress, + dCurv: dCurv, + ddCurv: ddCurv, + velocity: nextPose.velocity + } + } + + currentVelocity = nextPose.velocity; + predictionTime -= timeToNextIndex; + progress = 0; + nextIndex++; + } + } + + control(pose, wheelAngle, velocity, dt, lockPath = false) { + const pathPoses = this.path.poses; + const [nextIndex, progress, projection] = this.findNextIndex(pose.pos); + this.nextIndex = nextIndex; + + const prevPose = pathPoses[nextIndex - 1]; + const nextPose = pathPoses[nextIndex]; + + let gas = 0; + let brake = 0; + let steer = 0; + + if (nextIndex >= pathPoses.length - 2 && progress >= 1 - 1e-6) { + brake = 1; + } else { + /* + const kp_a = 4; + const kd_a = 0.5; + const kff_a = 0.5; + + const currentAccel = (velocity - this.prevVelocity) / dt; + const prevNextDist = nextPose.pos.distanceTo(prevPose.pos); + const targetVelocity = Math.sqrt(2 * nextPose.acceleration * prevNextDist * Math.clamp(progress, 0, 1) + prevPose.velocity * prevPose.velocity); + const diffVelocity = targetVelocity - velocity; + const diffAccel = nextPose.acceleration - currentAccel; + const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * nextPose.acceleration; + */ + const accelDamping = 0.1; + const targetAccel = nextPose.acceleration; + const dampedAccel = this.prevAccel * (1 - accelDamping) + targetAccel * accelDamping; + + if (dampedAccel > 0) + gas = Math.min(dampedAccel / Car.MAX_GAS_ACCEL, Car.MAX_GAS_ACCEL); + else + brake = Math.min(-dampedAccel / Car.MAX_BRAKE_DECEL, Car.MAX_BRAKE_DECEL); + + this.prevVelocity = velocity; + this.prevAccel = dampedAccel; + + const curvature = prevPose.curv + (nextPose.curv - prevPose.curv) * progress; + const desiredWheelAngle = Math.atan(curvature * Car.WHEEL_BASE); + const wheelAngleError = desiredWheelAngle - wheelAngle; + steer = Math.clamp(wheelAngleError / dt / Car.MAX_STEER_SPEED, -1, 1); + + if (lockPath) { + const damping = 0.1; + const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * progress); + const newPosition = new THREE.Vector2(projection.x - Car.REAR_AXLE_POS * Math.cos(newRotation), projection.y - Car.REAR_AXLE_POS * Math.sin(newRotation)); + + if (Math.abs(Math.wrapAngle(newRotation - this.car.rotation)) > 0.5) { + console.log('wut'); + } + + this.car.rotation += damping * Math.wrapAngle(newRotation - this.car.rotation); + this.car.position = this.car.position.clone().multiplyScalar(1 - damping).add(newPosition.multiplyScalar(damping)); + } + } + + return { gas, brake, steer }; + } + + findNextIndex(pos) { + const pathPoses = this.path.poses; + + // Constrain the search to just a few points surrounding the current nextIndex + // for performance and to avoid problems with a path that crosses itself + const start = Math.max(0, this.nextIndex - 20); + const end = Math.min(pathPoses.length - 1, this.nextIndex + 20); + let closestDistSqr = pos.distanceToSquared(pathPoses[start].pos); + let closestIndex = start; + + for (let i = start + 1; i < end; i++) { + const distSqr = pos.distanceToSquared(pathPoses[i].pos); + if (distSqr < closestDistSqr) { + closestDistSqr = distSqr; + closestIndex = i; + } + } + + if (closestIndex == pathPoses.length - 1) { + const [projection, progress] = projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos); + return [closestIndex, progress, projection]; + } else if (closestIndex == 0) { + const [projection, progress] = projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos); + return [closestIndex + 1, progress, projection]; + } else { + // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the pos to both + // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint) + // to determine which segment it's closest to. + const [precedingProjection, precedingProgress] = projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos); + const [succeedingProjection, succeedingProgress] = projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos); + + if (pos.distanceToSquared(precedingProjection) < pos.distanceToSquared(succeedingProjection)) { + return [closestIndex, precedingProgress, precedingProjection]; + } else { + return [closestIndex + 1, succeedingProgress, succeedingProjection]; + } + } + } +} + +// Returns [pointOnSegment, progressAlongSegment {0 - 1}] +function projectPointOnSegment(point, start, end) { + const distSqr = start.distanceToSquared(end); + const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr; + + const clampedProgress = Math.max(0, Math.min(1, progress)); + return [end.clone().sub(start).multiplyScalar(clampedProgress).add(start), clampedProgress]; +} diff --git a/seminar06-planning/simulator/js/autonomy/control/ManualController.js b/seminar06-planning/simulator/js/autonomy/control/ManualController.js new file mode 100644 index 0000000..ed10fce --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/control/ManualController.js @@ -0,0 +1,39 @@ +export default class ManualController { + constructor() { + this.carKeys = { forward: false, backward: false, left: false, right: false, brake: false }; + + document.addEventListener('keydown', event => { + switch (event.key) { + case 'w': case 'W': this.carKeys.forward = true; break; + case 's': case 'S': this.carKeys.backward = true; break; + case 'a': case 'A': this.carKeys.left = true; break; + case 'd': case 'D': this.carKeys.right = true; break; + case ' ': this.carKeys.brake = true; break; + } + }); + + document.addEventListener('keyup', event => { + switch (event.key) { + case 'w': case 'W': this.carKeys.forward = false; break; + case 's': case 'S': this.carKeys.backward = false; break; + case 'a': case 'A': this.carKeys.left = false; break; + case 'd': case 'D': this.carKeys.right = false; break; + case ' ': this.carKeys.brake = false; break; + } + }); + } + + control() { + let gas = 0; + let brake = 0; + let steer = 0; + + if (this.carKeys.forward) gas += 1; + if (this.carKeys.backward) gas -= 1; + if (this.carKeys.left) steer -= 1; + if (this.carKeys.right) steer += 1; + if (this.carKeys.brake) brake += 1; + + return { gas, brake, steer }; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/CubicPath.js b/seminar06-planning/simulator/js/autonomy/path-planning/CubicPath.js new file mode 100644 index 0000000..136c39a --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/CubicPath.js @@ -0,0 +1,205 @@ +const SIMPSONS_INTERVALS = 8; +const NEWTON_ITERATIONS = 16; +const RELAXATION_ITERATIONS = 32; +const CONVERGENCE_ERROR = 0.01; + +const jacobian = new THREE.Matrix3(); +const invJacobian = new THREE.Matrix3(); + +// Alternate reference implementation: https://github.com/ApolloAuto/apollo/blob/master/modules/planning/math/spiral_curve/cubic_spiral_curve.cc +export default class CubicPath { + constructor(start, end, params = null) { + this.start = Object.assign({}, start); + this.end = Object.assign({}, end); + + if (start.pos) { + this.start.x = start.pos.x; + this.start.y = start.pos.y + } + + if (end.pos) { + this.end.x = end.pos.x; + this.end.y = end.pos.y + } + + const diffX = this.end.x - this.start.x; + const diffY = this.end.y - this.start.y; + const sinRot = Math.sin(this.start.rot); + const cosRot = Math.cos(this.start.rot); + + this.goal = { + x: cosRot * diffX + sinRot * diffY, + y: -sinRot * diffX + cosRot * diffY, + rot: Math.wrapAngle(this.end.rot - this.start.rot), + curv: this.end.curv + }; + + if (params) + this.params = Object.assign({}, params, { p0: this.start.curv, p3: this.end.curv }); + else + this.guessInitialParams(); + + this.converged = false; + } + + guessInitialParams() { + const originalGoal = this.goal; + const dStartCurv = this.start.curv / RELAXATION_ITERATIONS; + const dGoalY = originalGoal.y / RELAXATION_ITERATIONS; + const dGoalRot = originalGoal.rot / RELAXATION_ITERATIONS; + const dGoalCurv = originalGoal.curv / RELAXATION_ITERATIONS; + + this.goal = { + x: originalGoal.x, + y: 0, + rot: 0, + curv: 0 + }; + + this.params = { + p0: 0, + p1: 0, + p2: 0, + p3: 0, + sG: originalGoal.x + }; + + for (let i = 0; i < RELAXATION_ITERATIONS; i++) { + this.params.p0 += dStartCurv; + this.params.p3 += dGoalCurv; + this.goal.y += dGoalY; + this.goal.rot += dGoalRot; + this.goal.curv += dGoalCurv; + + this.iterate(); + } + + this.goal = originalGoal; + } + + optimize() { + for (let i = 0; i < NEWTON_ITERATIONS; i++) { + if (this.iterate()) { + this.converged = true; + return true; + } + } + + this.converged = false; + return false; + } + + iterate() { + const { p0, p1, p2, p3, sG } = this.params; + + const ds = sG / SIMPSONS_INTERVALS; + const sG_2 = sG * sG; + const sG_3 = sG_2 * sG; + + let dX_p1 = 0; + let dX_p2 = 0; + let dX_sG = 0; + let dY_p1 = 0; + let dY_p2 = 0; + let dY_sG = 0; + let guessX = 0; + let guessY = 0; + + let theta, cosTheta, sinTheta, dT_p1, dT_p2, dT_sG; + + for (let i = 0, s = 0; i <= SIMPSONS_INTERVALS; i++, s += ds) { + const coeff = i == 0 || i == SIMPSONS_INTERVALS ? 1 : i % 2 == 0 ? 2 : 4; + + const a = p0; + const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG; + const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2; + const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3; + + theta = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s; + cosTheta = Math.cos(theta); + sinTheta = Math.sin(theta); + + const s_sG = s / sG; + dT_p1 = ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s; + dT_p2 = ((-3.375 * s_sG + 6) * s_sG - 2.25) * s_sG * s; + 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; + + dX_p1 -= coeff * sinTheta * dT_p1; + dX_p2 -= coeff * sinTheta * dT_p2; + dX_sG -= coeff * sinTheta * dT_sG; + + dY_p1 += coeff * cosTheta * dT_p1; + dY_p2 += coeff * cosTheta * dT_p2; + dY_sG += coeff * cosTheta * dT_sG; + + guessX += coeff * cosTheta; + guessY += coeff * sinTheta; + } + + // After the Simpson's integration loop, `theta`, `cosTheta`, `sinTheta`, + // `dT_p1`, `dT_p2`, and `dT_sG` hold the appropriate values for `sG`. + + const hOver3 = sG / SIMPSONS_INTERVALS / 3; + + const deltaX = this.goal.x - guessX * hOver3; + const deltaY = this.goal.y - guessY * hOver3; + const deltaRot = Math.wrapAngle(this.goal.rot - theta); + + if (Math.abs(deltaX) + Math.abs(deltaY) + Math.abs(deltaRot) < CONVERGENCE_ERROR) + return true; + + jacobian.set( + dX_p1 * hOver3, dX_p2 * hOver3, cosTheta + dX_sG * hOver3, + dY_p1 * hOver3, dY_p2 * hOver3, sinTheta + dY_sG * hOver3, + dT_p1, dT_p2, dT_sG + ); + + const [m11, m21, m31, m12, m22, m32, m13, m23, m33] = invJacobian.getInverse(jacobian).elements; + + this.params.p1 += m11 * deltaX + m12 * deltaY + m13 * deltaRot; + this.params.p2 += m21 * deltaX + m22 * deltaY + m23 * deltaRot; + this.params.sG += m31 * deltaX + m32 * deltaY + m33 * deltaRot; + + return false; + } + + buildPath(num) { + const { p0, p1, p2, p3, sG } = this.params; + + const sG_2 = sG * sG; + const sG_3 = sG_2 * sG; + + const a = p0; + const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG; + const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2; + const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3; + + const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }]; + const ds = sG / (num - 1); + let s = ds; + let dx = 0; + let dy = 0; + let prevCosRot = Math.cos(path[0].rot); + let prevSinRot = Math.sin(path[0].rot); + + for (let i = 1; i < num - 1; i++) { + const rot = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s + this.start.rot; + const curv = ((d * s + c) * s + b) * s + a; + const cosRot = Math.cos(rot); + const sinRot = Math.sin(rot); + + dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i); + dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i); + + path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv }); + + s += ds; + prevCosRot = cosRot; + prevSinRot = sinRot; + } + + path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv }); + + return path; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/ExternalPlanner.js b/seminar06-planning/simulator/js/autonomy/path-planning/ExternalPlanner.js new file mode 100644 index 0000000..c89e613 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/ExternalPlanner.js @@ -0,0 +1,53 @@ + +export default class ExternalPathPlanner { + _PLANNING_SERVER_URL = 'http://127.0.0.1:9999/' + + plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) { + const state = { + vehiclePose: vehiclePose, + vehicleStation: vehicleStation, + lanePath: lanePath, + startTime: startTime, + staticObstacles: staticObstacles, + dynamicObstacles: dynamicObstacles, + }; + + var jsonToSend = JSON.stringify(state); + const response = this._send_request(jsonToSend, 'plan'); + const path = JSON.parse(response)['states']; + + return { + planner_state: "ok", + path: path, + fromVehicleSegment: [], + fromVehicleParams: { type:'null' }, + latticeStartStation: null, + dynamicObstacleGrid: null + }; + } + + reset() { + //this.notify_scenario_status({status: "restart"}); + } + + notify_scenario_status(status) { + var jsonToSend = JSON.stringify(status); + this._send_request(jsonToSend, 'notify_case_status'); + } + + _send_request(jsonToSend, request_name) { + var url = this._PLANNING_SERVER_URL + request_name; + + var xhr = new XMLHttpRequest(); + xhr.timeout = 5000; + xhr.open('POST', url, false); // the 'false' makes the request synchronous + xhr.setRequestHeader('Content-Type', 'application/json'); + xhr.send(jsonToSend); + + if (xhr.status === 200) { + return xhr.responseText; + } else { + console.error('There was an error with the request'); + } + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/PathPlanner.js b/seminar06-planning/simulator/js/autonomy/path-planning/PathPlanner.js new file mode 100644 index 0000000..15ac571 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/PathPlanner.js @@ -0,0 +1,470 @@ +import GPGPU from "../../GPGPU.js"; +import Car from "../../physics/Car.js"; +import CubicPath from "./CubicPath.js"; +import QuinticPath from "./QuinticPath.js"; +import xyObstacleGrid from "./gpgpu-programs/xyObstacleGrid.js"; +import slObstacleGrid from "./gpgpu-programs/slObstacleGrid.js"; +import slObstacleGridDilation from "./gpgpu-programs/slObstacleGridDilation.js"; +import slDynamicObstacleGrid from "./gpgpu-programs/slDynamicObstacleGrid.js"; +import xyslMap from "./gpgpu-programs/xyslMap.js"; +import optimizeCubicPaths from "./gpgpu-programs/optimizeCubicPaths.js"; +import optimizeQuinticPaths from "./gpgpu-programs/optimizeQuinticPaths.js"; +import pathFromVehicleCosts from "./gpgpu-programs/pathFromVehicleCosts.js"; +import graphSearch from "./gpgpu-programs/graphSearch.js"; +import xyObstacleCostGrid from "./gpgpu-programs/xyObstacleCostGrid.js"; + +const NUM_ACCELERATION_PROFILES = 8; +const NUM_VELOCITY_RANGES = 4; +const NUM_TIME_RANGES = 2; + +/* Obstacle cost map: + * + * 1. Rasterize triangles from polygonal obstacles into XY-space occupancy grid + * 2. Convert occupancy grid to SL-space + * * Width is spatial horizon of the state lattice + * * Height is lane width + * * Resolution should be higher than XY-grid + * * Get XY position from centerline texture + * * Lookup XY in XY occupancy grid (nearest) + * 3. Dilate SL-space grid using two passes (along station, then along latitude) + * * collision area: half car size + 0.3m + * * high cost area: 1 meter + * 4. Convert back to XY-space using XYSL map + */ + +export default class PathPlanner { + constructor() { + this.previousStartStation = null; + this.previousFirstLatticePoint = -1; + this.previousSecondLatticePoint = -1; + this.previousFirstAcceleration = -1; + this.previousSecondLatticePoint = -1; + + let start = performance.now(); + const programs = [ + xyObstacleGrid.setUp(), + slObstacleGrid.setUp(), + ...slObstacleGridDilation.setUp(), + slDynamicObstacleGrid.setUp(), + xyslMap.setUp(), + ...optimizeCubicPaths.setUp(), + optimizeQuinticPaths.setUp(), + ...pathFromVehicleCosts.setUp(), + graphSearch.setUp(), + ].map(p => Object.assign({}, p, { width: 1, height: 1 })); + + this.gpgpu = new GPGPU(programs); + } + + reset() { + this.previousStartStation = null; + this.previousFirstLatticePoint = -1; + this.previousSecondLatticePoint = -1; + this.previousFirstAcceleration = -1; + this.previousSecondLatticePoint = -1; + } + + plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) { + const latticeStationInterval = this._latticeStationInterval(); + + const centerlineRaw = lanePath.sampleStations(vehicleStation, Math.ceil((this.config.spatialHorizon + latticeStationInterval) / this.config.centerlineStationInterval) + 1, this.config.centerlineStationInterval); + + // Transform all centerline points into vehicle frame + const vehicleXform = vehicleTransform(vehiclePose); + const centerline = centerlineRaw.map(c => { return { pos: c.pos.clone().applyMatrix3(vehicleXform), rot: c.rot - vehiclePose.rot, curv: c.curv } }); + + const centerlineData = new Float32Array(centerline.length * 3); + const maxPoint = new THREE.Vector2(0, 0); + const minPoint = new THREE.Vector2(0, 0); + + for (let i = 0; i < centerline.length; i++) { + const sample = centerline[i]; + const pos = sample.pos; + centerlineData[i * 3 + 0] = pos.x; + centerlineData[i * 3 + 1] = pos.y; + centerlineData[i * 3 + 2] = sample.rot; + + maxPoint.max(pos); + minPoint.min(pos); + } + + const diff = maxPoint.clone().sub(minPoint); + const xyCenterPoint = minPoint.clone().add(maxPoint).divideScalar(2); + + // Sizes of the xy grids (in pixels, not meters) + const xyWidth = Math.ceil((diff.x + this.config.gridMargin * 2) / this.config.xyGridCellSize); + const xyHeight = Math.ceil((diff.y + this.config.gridMargin * 2) / this.config.xyGridCellSize); + + const stationWidth = this.config.spatialHorizon + latticeStationInterval * 2; + const slCenterPoint = new THREE.Vector2(this.config.spatialHorizon / 2, 0); + + // Sizes of the sl grids (in pixels, not meters) + const slWidth = Math.ceil(stationWidth / this.config.slGridCellSize); + const slHeight = Math.ceil((this.config.roadWidth + this.config.gridMargin * 2) / this.config.slGridCellSize); + + let startStation; + + if (this.previousStartStation === null || vehicleStation + latticeStationInterval / 2 > this.previousStartStation) { + startStation = (this.previousStartStation === null ? vehicleStation : this.previousStartStation) + latticeStationInterval; + this.previousStartStation = startStation; + this.previousFirstLatticePoint -= this.config.lattice.numLatitudes; + this.previousSecondLatticePoint -= this.config.lattice.numLatitudes; + } else { + startStation = this.previousStartStation; + } + + const lattice = this._buildLattice(lanePath, startStation, vehiclePose.rot, vehicleXform); + + const temporalHorizon = this.config.spatialHorizon / this.config.speedLimit; + const dynamicFrameTime = temporalHorizon / this.config.numDynamicFrames; + + for (const [i, p] of [ + xyObstacleGrid.update(this.config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, staticObstacles), + slObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, xyCenterPoint), + ...slObstacleGridDilation.update(this.config, slWidth, slHeight), + slDynamicObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles), + xyslMap.update(this.config, xyWidth, xyHeight, xyCenterPoint), + ...optimizeCubicPaths.update(this.config, vehiclePose), + optimizeQuinticPaths.update(this.config, vehiclePose), + ...pathFromVehicleCosts.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime), + graphSearch.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime) + ].entries()) { + this.gpgpu.updateProgram(i, p); + } + + this.gpgpu.updateSharedTextures({ + centerline: { + width: centerline.length, + height: 1, + channels: 3, + filter: 'linear', + data: centerlineData + }, + costTable: { + width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES, + height: this.config.lattice.numLatitudes, + depth: this.config.lattice.numStations, + channels: 4, + textureType: '2DArray' + }, + lattice: { + width: this.config.lattice.numLatitudes, + height: this.config.lattice.numStations, + channels: 4, + data: lattice + } + }); + + this.gpgpu._graphSearchCostTable = null; + this.gpgpu._dynamicObstacleGrid = null; + + let start = performance.now(); + const outputs = this.gpgpu.run(); + const costTable = this.gpgpu._graphSearchCostTable; + const cubicPathParams = outputs[6]; + const cubicPathFromVehicleParams = outputs[7]; + const quinticPathFromVehicleParams = outputs[8]; + + let bestEntry = [Number.POSITIVE_INFINITY]; + let bestEntryIndex; + const numEntries = costTable.length / 4; + + for (let i = 0; i < numEntries; i++) { + const entryUnpacked = this._unpackCostTableIndex(i); + const entry = [ + costTable[i * 4], + costTable[i * 4 + 1], + costTable[i * 4 + 2], + costTable[i * 4 + 3] + ]; + + if (entry[0] < 0) continue; + + entry[0] += this._terminalCost(entryUnpacked, entry); + + if (entry[0] < bestEntry[0]) { + bestEntryIndex = i; + bestEntry = entry; + } + } + + const inverseVehicleXform = (new THREE.Matrix3()).getInverse(vehicleXform); + let bestTrajectory = null; + let fromVehicleSegment = null; + let fromVehicleParams = null; + let firstLatticePoint = -1; + let firstAcceleration = -1; + let secondLatticePoint = -1; + let secondAcceleration = -1; + + if (isFinite(bestEntry[0])) { + [bestTrajectory, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration] = this._reconstructTrajectory( + bestEntryIndex, + costTable, + cubicPathParams, + cubicPathFromVehicleParams, + quinticPathFromVehicleParams, + vehiclePose, + lattice + ); + + fromVehicleSegment.forEach(p => { + p.pos = p.pos.applyMatrix3(inverseVehicleXform); + p.rot += vehiclePose.rot; + }); + + bestTrajectory.forEach(p => { + p.pos = p.pos.applyMatrix3(inverseVehicleXform); + p.rot += vehiclePose.rot; + }); + } + + this.previousFirstLatticePoint = firstLatticePoint; + this.previousFirstAcceleration = firstAcceleration; + this.previousSecondLatticePoint = secondLatticePoint; + this.previousSecondAcceleration = secondAcceleration; + + return { + path: bestTrajectory, + fromVehicleSegment: fromVehicleSegment, + fromVehicleParams: fromVehicleParams, + latticeStartStation: this.previousStartStation, + dynamicObstacleGrid: { data: this.gpgpu._dynamicObstacleGrid, width: slWidth, height: slHeight } + }; + } + + _buildLattice(lanePath, startStation, vehicleRot, vehicleXform) { + const centerline = lanePath.sampleStations(startStation, this.config.lattice.numStations, this._latticeStationInterval()); + const offset = Math.floor(this.config.lattice.numLatitudes / 2); + const lattice = new Float32Array(this.config.lattice.numStations * this.config.lattice.numLatitudes * 4); + let index = 0; + + for (let s = 0; s < centerline.length; s++) { + const sample = centerline[s]; + + for (let l = 0; l < this.config.lattice.numLatitudes; l++) { + const latitude = (l - offset) / offset * this.config.roadWidth / 2; + const rot = sample.rot - vehicleRot; + const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos.clone().applyMatrix3(vehicleXform)); + const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude); + + lattice[index++] = pos.x; + lattice[index++] = pos.y; + lattice[index++] = rot; + lattice[index++] = curv; + } + } + + return lattice; + } + + _latticeStationInterval() { + return this.config.spatialHorizon / this.config.lattice.numStations; + } + + _terminalCost([stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex], [cost, finalVelocity, finalTime, incomingIndex]) { + // Only consider vertices that reach the end of the spatial or temporal horizon + if (stationIndex != this.config.lattice.numStations - 1 && finalVelocity > 0.05) + return Number.POSITIVE_INFINITY; + + const station = (this.config.spatialHorizon / this.config.lattice.numStations) * (stationIndex + 1); + + return station * -this.config.stationReachDiscount + finalTime * this.config.extraTimePenalty; + } + + _unpackCostTableIndex(index) { + if (index < 0) return [-1, index + 2, null, null, null]; + + const numPerTime = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES; + const numPerLatitude = numPerTime * NUM_TIME_RANGES; + const numPerStation = this.config.lattice.numLatitudes * numPerLatitude; + + const stationIndex = Math.floor(index / numPerStation); + index -= stationIndex * numPerStation; + + const latitudeIndex = Math.floor(index / numPerLatitude); + index -= latitudeIndex * numPerLatitude; + + const timeIndex = Math.floor(index / numPerTime); + index -= timeIndex * numPerTime; + + const velocityIndex = Math.floor(index / NUM_ACCELERATION_PROFILES); + const accelerationIndex = index % NUM_ACCELERATION_PROFILES; + + return [stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex]; + } + + _reconstructTrajectory(index, costTable, cubicPathParams, cubicPathFromVehicleParams, quinticPathFromVehicleParams, vehiclePose, lattice) { + let unpacked = this._unpackCostTableIndex(index); + unpacked.push(costTable[index * 4 + 1]); + const nodes = [unpacked]; + + let count = 0; + while (unpacked[0] >= 0 && count++ < 100) { + index = costTable[index * 4 + 3]; + unpacked = this._unpackCostTableIndex(index); + + const finalVelocity = unpacked[0] >= 0 ? costTable[index * 4 + 1] : vehiclePose.velocity; + unpacked.push(finalVelocity); + + nodes.unshift(unpacked); + } + if (count >= 100) throw new Error('Infinite loop encountered while reconstructing trajectory.'); + + const points = []; + let fromVehicleSegment = []; + let fromVehicleParams = null; + + for (let i = 0; i < nodes.length - 1; i++) { + const [prevStation, prevLatitude, _pt, _pv, _pa, prevVelocity] = nodes[i]; + const [station, latitude, _t, _v, _a, velocity] = nodes[i + 1]; + + let length; + let pathBuilder; + + if (prevStation < 0) { + const start = { + pos: new THREE.Vector2(0, 0), + rot: 0, + curv: vehiclePose.curv + }; + + const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4; + const end = { + pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]), + rot: lattice[endIndex + 2], + curv: lattice[endIndex + 3] + }; + + if (prevLatitude == 0) { // Cubic path from vehicle to lattice node + length = cubicPathFromVehicleParams[endIndex + 2]; + + const params = { + p1: cubicPathFromVehicleParams[endIndex], + p2: cubicPathFromVehicleParams[endIndex + 1], + sG: length + }; + + pathBuilder = new CubicPath(start, end, params); + + fromVehicleParams = { type: 'cubic', params: params }; + } else { // Quintic path from vehicle to lattice node + length = quinticPathFromVehicleParams[endIndex + 2]; + + const params = { + p3: quinticPathFromVehicleParams[endIndex], + p4: quinticPathFromVehicleParams[endIndex + 1], + sG: length + }; + + pathBuilder = new QuinticPath(start, end, params); + + fromVehicleParams = { type: 'quintic', params: params }; + } + } else { + const startIndex = (prevStation * this.config.lattice.numLatitudes + prevLatitude) * 4; + const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4; + + const start = { + pos: new THREE.Vector2(lattice[startIndex], lattice[startIndex + 1]), + rot: lattice[startIndex + 2], + curv: lattice[startIndex + 3] + }; + + const end = { + pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]), + rot: lattice[endIndex + 2], + curv: lattice[endIndex + 3] + }; + + const slIndex = station * this.config.lattice.numLatitudes + latitude; + const connectivityIndex = (prevStation - station + this.config.lattice.stationConnectivity) * this.config.lattice.latitudeConnectivity + prevLatitude - latitude + Math.floor(this.config.lattice.latitudeConnectivity / 2); + const cubicPathIndex = (connectivityIndex * this.config.lattice.numStations * this.config.lattice.numLatitudes + slIndex) * 4; + + length = cubicPathParams[cubicPathIndex + 2]; + + pathBuilder = new CubicPath(start, end, { + p1: cubicPathParams[cubicPathIndex], + p2: cubicPathParams[cubicPathIndex + 1], + sG: length + }); + } + + const path = pathBuilder.buildPath(Math.ceil(length / 0.25)); + + const prevVelocitySq = prevVelocity * prevVelocity; + const accel = (velocity * velocity - prevVelocitySq) / 2 / length; + const ds = length / (path.length - 1); + let s = 0; + + for (let p = 0; p < path.length; p++) { + path[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq); + path[p].acceleration = accel; + s += ds; + } + + if (prevStation < 0) { + fromVehicleSegment = path; + } else { + if (i > 0) path.shift(); + points.push(...path); + } + } + + let firstLatticePoint = null + let firstAcceleration = null; + let secondLatticePoint = null; + let secondAcceleration = null; + + if (nodes.length >= 2) { + firstLatticePoint = nodes[1][0] * this.config.lattice.numLatitudes + nodes[1][1]; + firstAcceleration = nodes[1][4]; + } + + if (nodes.length >= 3) { + secondLatticePoint = nodes[2][0] * this.config.lattice.numLatitudes + nodes[2][1]; + secondAcceleration = nodes[2][4]; + } + + return [points, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration]; + } +} + +function vehicleTransform({ pos, rot }) { + const translate = new THREE.Matrix3(); + translate.set( + 1, 0, -pos.x, + 0, 1, -pos.y, + 0, 0, 1 + ); + + const cosRot = Math.cos(rot); + const sinRot = Math.sin(rot); + + const rotate = new THREE.Matrix3(); + rotate.set( + cosRot, sinRot, 0, + -sinRot, cosRot, 0, + 0, 0, 1 + ); + + return rotate.multiply(translate); +} + +function obstacleTransform(vehicleXform, xyCenterPoint, width, height) { + const translate = new THREE.Matrix3(); + translate.set( + 1, 0, -xyCenterPoint.x, + 0, 1, -xyCenterPoint.y, + 0, 0, 1 + ); + + const scale = new THREE.Matrix3(); + scale.set( + 2 / width, 0, 0, + 0, 2 / height, 0, + 0, 0, 1 + ); + + return scale.multiply(translate).multiply(vehicleXform); +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/QuinticPath.js b/seminar06-planning/simulator/js/autonomy/path-planning/QuinticPath.js new file mode 100644 index 0000000..21d563e --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/QuinticPath.js @@ -0,0 +1,72 @@ +export default class QuinticPath { + constructor(start, end, params) { + this.start = Object.assign({}, start); + this.end = Object.assign({}, end); + + if (start.pos) { + this.start.x = start.pos.x; + this.start.y = start.pos.y + } + + if (end.pos) { + this.end.x = end.pos.x; + this.end.y = end.pos.y + } + + const diffX = this.end.x - this.start.x; + const diffY = this.end.y - this.start.y; + const sinRot = Math.sin(this.start.rot); + const cosRot = Math.cos(this.start.rot); + + this.goal = { + x: cosRot * diffX + sinRot * diffY, + y: -sinRot * diffX + cosRot * diffY, + rot: Math.wrapAngle(this.end.rot - this.start.rot), + curv: this.end.curv + }; + + this.params = Object.assign({}, params, { p0: this.start.curv, p1: this.start.dCurv || 0, p2: this.start.ddCurv || 0, p5: this.end.curv }); + } + + buildPath(num) { + const { p0, p1, p2, p3, p4, p5, sG } = this.params; + + const sG_2 = sG * sG; + const sG_3 = sG_2 * sG; + + const a = p0; + const b = p1; + const c = p2 / 2.0; + const d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3; + const 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); + const 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); + + const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }]; + const ds = sG / (num - 1); + let s = ds; + let dx = 0; + let dy = 0; + let prevCosRot = Math.cos(path[0].rot); + let prevSinRot = Math.sin(path[0].rot); + + for (let i = 1; i < num - 1; i++) { + const rot = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s + this.start.rot; + const curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a; + const cosRot = Math.cos(rot); + const sinRot = Math.sin(rot); + + dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i); + dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i); + + path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv }); + + s += ds; + prevCosRot = cosRot; + prevSinRot = sinRot; + } + + path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv }); + + return path; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/RoadLattice.js b/seminar06-planning/simulator/js/autonomy/path-planning/RoadLattice.js new file mode 100644 index 0000000..0a62a46 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/RoadLattice.js @@ -0,0 +1,24 @@ +export default class RoadLattice { + constructor(lanePath, latticeStartStation, config) { + const stationInterval = config.spatialHorizon / config.lattice.numStations; + const centerline = lanePath.sampleStations(latticeStartStation, config.lattice.numStations, stationInterval); + const lattice = new Array(centerline.length); + const offset = Math.floor(config.lattice.numLatitudes / 2); + + for (let s = 0; s < centerline.length; s++) { + const sample = centerline[s]; + const latitudes = lattice[s] = new Array(config.lattice.numLatitudes); + + for (let l = 0; l < config.lattice.numLatitudes; l++) { + const latitude = (l - offset) / offset * config.roadWidth / 2; + const rot = sample.rot; + const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos); + const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude); + + latitudes[l] = { pos, rot, curv }; + } + } + + this.lattice = lattice; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearch.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearch.js new file mode 100644 index 0000000..74a45c2 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearch.js @@ -0,0 +1,267 @@ +/* State Lattice Cost Map + * + * 5-dimensional node: station, latitude, acceleration profile, velocity, time + * + * A draw call per station s + * * Input to kernel: latitude l, acceleration profile a, velocity range v, time range t + * * Find all SL vertices that can connect to this node + * * For each of those vertices, check if any terminate in this specific velocity and time range + * * Based on initial velocity, initial time, and acceleration + * * Each connected SL vertex should have a * v * t nodes that could possibly terminate at this node + * * For all valid edges, find the one with the lowest cost + * + * Input: + * * 2D texture array cost map + * * Height: num of latitudes (~20) + * * Width: num of acceleration profiles * num of time ranges * num of velocity ranges (8 * 2 * 4 = ~64) + * * A flattened 3D array: + * d1: acceleration + * d2: velocity + * d3: time + * * Layer: num of stations (~10) + * + * Output: + * * 2D texture slice of the next station in the input 2D texture array cost map + * + * Cost Map Elements: + * * Traversal cost so far + * * Ending velocity + * * Ending time + * * Index of parent node + * + * Since one cubic path can be shared between multiple trajectories, they need to be pre-optimized. + * + * Quintic Paths: + * Stations 0 through (numStations - 1) correspond to the stations on the lattice; however, + * a new station (station -1) will be used to signifiy the single vehicle pose node. Either + * a cubic path or quintic path can be used to connect this single node to the lattice + * (depending on vehicle velocity). At station -1, latitude 0 will correspond to a cubic path, + * and latitude 1 will correspond to a quintic path. All other latitudes will be skipped. + */ + +import { 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"; + +const SOLVE_STATION_KERNEL = + SHARED_SHADER + + SAMPLE_CUBIC_PATH_FN + + SAMPLE_QUINTIC_PATH_FN + + +` + +vec4 kernel() { + ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize)); + + int latitude = indexes.y; + + int numPerTime = numAccelerations * numVelocities; + int timeIndex = indexes.x / numPerTime; + indexes.x -= timeIndex * numPerTime; + int velocityIndex = indexes.x / numAccelerations; + int accelerationIndex = int(mod(float(indexes.x), float(numAccelerations))); + + int minLatitude = max(latitude - latitudeConnectivity / 2, 0); + int maxLatitude = min(latitude + latitudeConnectivity / 2, numLatitudes - 1); + + int slIndex = station * numLatitudes + latitude; + + vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0); + + float minVelocity = velocityRanges[velocityIndex]; + float maxVelocity = velocityRanges[velocityIndex + 1]; + + float minTime = timeRanges[timeIndex]; + float maxTime = timeRanges[timeIndex + 1]; + + vec4 bestTrajectory = vec4(-1); // -1 means infinite cost + float bestTerminalCost = 1.0 / 0.0; + + float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount; + + for (int prevStation = max(station - stationConnectivity, 0); prevStation < station; prevStation++) { + int stationConnectivityIndex = prevStation - station + stationConnectivity; + + for (int prevLatitude = minLatitude; prevLatitude <= maxLatitude; prevLatitude++) { + int latitudeConnectivityIndex = prevLatitude - latitude + latitudeConnectivity / 2; + int connectivityIndex = stationConnectivityIndex * latitudeConnectivity + latitudeConnectivityIndex; + + vec4 pathStart = texelFetch(lattice, ivec2(prevLatitude, prevStation), 0); + vec4 cubicPathParams = texelFetch(cubicPaths, ivec2(slIndex, connectivityIndex), 0); + + // If the path didn't converge + if (cubicPathParams.w == 0.0) continue; + + int numSamples = sampleCubicPath(pathStart, pathEnd, cubicPathParams); + float pathLength = cubicPathParams.z; + + if (numSamples < 2) continue; + + float averageStaticCost = calculateAverageStaticCost(numSamples); + if (averageStaticCost < 0.0) continue; + + averageStaticCost += hysteresisAdjustment; + + if (averageStaticCost * pathLength >= bestTerminalCost) continue; + + for (int prevVelocity = 0; prevVelocity < numVelocities; prevVelocity++) { + for (int prevTime = 0; prevTime < numTimes; prevTime++) { + for (int prevAccel = 0; prevAccel < numAccelerations; prevAccel++) { + int avtIndex = prevTime * numPerTime + prevVelocity * numAccelerations + prevAccel; + + // Cost table entry: + // x: cost so far + // y: end velocity + // z: end time + // w: parent index + vec4 costTableEntry = texelFetch(costTable, ivec3(avtIndex, prevLatitude, prevStation), 0); + + // If cost entry is infinity + if (costTableEntry.x < 0.0 || averageStaticCost * pathLength + costTableEntry.x >= bestTerminalCost) continue; + + vec3 avt = calculateAVT(accelerationIndex, costTableEntry.y, costTableEntry.z, pathLength); + float acceleration = avt.x; + float finalVelocity = avt.y; + float finalTime = avt.z; + + if (averageStaticCost * pathLength + costTableEntry.x + extraTimePenalty * finalTime >= bestTerminalCost) continue; + + // If the calculated final velocity does not match this fragment's velocity range, then skip this trajectory + if (finalVelocity < minVelocity || finalVelocity >= maxVelocity) continue; + + // If the calculated final time does not match this fragment's time range, then skip this trajectory + if (finalTime < minTime || finalTime >= maxTime) continue; + + float abandonThreshold = (bestTerminalCost - extraTimePenalty * finalTime - costTableEntry.x) / pathLength - averageStaticCost; + float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, costTableEntry.z, costTableEntry.y, acceleration, abandonThreshold); + if (averageDynamicCost < 0.0) continue; + + if (accelerationIndex != prevAccel) + averageDynamicCost += accelerationChangePenalty; + + // The cost of a trajectory is the average sample cost scaled by the path length + float totalCost = (averageStaticCost + averageDynamicCost) * pathLength + costTableEntry.x; + + float terminalCost = totalCost + extraTimePenalty * finalTime; + if (terminalCost >= bestTerminalCost) continue; + bestTerminalCost = terminalCost; + + int incomingIndex = avtIndex + numPerTime * numTimes * (prevLatitude + numLatitudes * prevStation); + bestTrajectory = vec4(totalCost, finalVelocity, finalTime, incomingIndex); + } + } + } + } + } + + if (station < stationConnectivity) { + ivec2 slaIndex = ivec2(latitude, station * numAccelerations + accelerationIndex); + + vec4 costTableEntry = texelFetch(cubicPathFromVehicleCosts, slaIndex, 0); + float terminalCost; + + if (costTableEntry.x >= 0.0) { + terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z; + + if (terminalCost < bestTerminalCost) { + bestTerminalCost = terminalCost; + bestTrajectory = costTableEntry; + } + } + + costTableEntry = texelFetch(quinticPathFromVehicleCosts, slaIndex, 0); + + if (costTableEntry.x >= 0.0) { + terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z; + + if (terminalCost < bestTerminalCost) { + bestTerminalCost = terminalCost; + bestTrajectory = costTableEntry; + } + } + } + + return bestTrajectory; +} + +`; + +export default { + setUp() { + return { + kernel: SOLVE_STATION_KERNEL, + output: { name: 'graphSearch' }, + uniforms: Object.assign({}, SHARED_UNIFORMS, { + lattice: { type: 'sharedTexture' }, + costTable: { type: 'sharedTexture', textureType: '2DArray' }, + cubicPaths: { type: 'outputTexture' }, + cubicPathFromVehicleCosts: { type: 'outputTexture' }, + quinticPathFromVehicleCosts: { type: 'outputTexture' }, + firstLatticePoint: { type: 'int' }, + secondLatticePoint: { type: 'int' }, + velocityVehicle: { type: 'float' }, + curvVehicle: { type: 'float' }, + dCurvVehicle: { type: 'float' }, + ddCurvVehicle: { type: 'float' }, + extraTimePenalty: { type: 'float' }, + hysteresisDiscount: { type: 'float' }, + accelerationChangePenalty: { type: 'float' }, + numStations: { type: 'int' }, + numLatitudes: { type: 'int' }, + numAccelerations: { type: 'int' }, + numVelocities: { type: 'int' }, + numTimes: { type: 'int' }, + stationConnectivity: { type: 'int' }, + latitudeConnectivity: { type: 'int' }, + velocityRanges: { type: 'float', length: NUM_VELOCITY_RANGES + 1 }, + timeRanges: { type: 'float', length: NUM_TIME_RANGES + 1 }, + station: { type: 'int' } // Updated in `drawProxy` + }), + drawProxy: (gpgpu, program, draw) => { + const width = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES; + const height = program.meta.lattice.numLatitudes; + const costTable = new Float32Array(width * height * program.meta.lattice.numStations * 4); + + for (let s = 0; s < program.meta.lattice.numStations; s++) { + gpgpu.updateProgramUniforms(program, { station: s }); + draw(); + + gpgpu.gl.readPixels(0, 0, width, height, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, costTable, s * width * height * 4); + + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D_ARRAY, gpgpu.sharedTextures.costTable); + gpgpu.gl.copyTexSubImage3D(gpgpu.gl.TEXTURE_2D_ARRAY, 0, 0, 0, s, 0, 0, width, height); + } + + gpgpu._graphSearchCostTable = costTable; + } + }; + }, + + update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) { + return { + width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES, + height: config.lattice.numLatitudes, + meta: { + lattice: config.lattice + }, + uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), { + firstLatticePoint: firstLatticePoint, + secondLatticePoint: secondLatticePoint, + velocityVehicle: pose.velocity, + curvVehicle: pose.curv, + dCurvVehicle: pose.dCurv, + ddCurvVehicle: pose.ddCurv, + extraTimePenalty: config.extraTimePenalty, + hysteresisDiscount: config.hysteresisDiscount, + accelerationChangePenalty: config.accelerationChangePenalty, + numStations: config.lattice.numStations, + numLatitudes: config.lattice.numLatitudes, + numAccelerations: NUM_ACCELERATION_PROFILES, + numVelocities: NUM_VELOCITY_RANGES, + numTimes: NUM_TIME_RANGES, + stationConnectivity: config.lattice.stationConnectivity, + latitudeConnectivity: config.lattice.latitudeConnectivity, + velocityRanges: [0, config.speedLimit / 3, config.speedLimit * 2 / 3, config.speedLimit, 1000000], + timeRanges: [0, 10, 1000000] + }) + }; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js new file mode 100644 index 0000000..e48bb8b --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js @@ -0,0 +1,308 @@ +const SHARED_SHADER = ` + +const float smallV = 0.01; +vec4 pathSamples[128]; +float pathSampleCurvRates[128]; + +float calculateAcceleration(int index, float initialVelocitySq, float distance) { + if (index <= 4) { + // [aMaxHard, aMinHard, aMaxSoft, aMinSoft, 0] + return accelerationProfiles[index]; + } else { + float finalVelocity = finalVelocityProfiles[index - 5]; + if (distance < 0.001) return 0.0; + return clamp((finalVelocity * finalVelocity - initialVelocitySq) / (2.0 * distance), accelerationProfiles[1], accelerationProfiles[0]); + } +} + +vec2 xy2sl(vec4 xytk) { + vec2 xy = xytk.xy + rearAxleToCenter * vec2(cos(xytk.z), sin(xytk.z)); + vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5; + return texture(xyslMap, xyTexCoords).xy; +} + +float sampleStaticCost(vec4 xytk) { + vec2 sl = xy2sl(xytk); + vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5; + float obstacleCost = texture(slObstacleGrid, slTexCoords).r; + + if (obstacleCost >= 0.75) return -1.0; // Infinite cost + + obstacleCost = step(0.25, obstacleCost) * obstacleHazardCost; + + float absLatitude = abs(sl.y); + if (absLatitude >= laneShoulderLatitude) return -1.0; + + float laneCost = abs(absLatitude - laneCenterLatitude) * laneCostSlope + step(0.0, -sl.y * sign(lanePreference)) * lanePreferenceDiscount; + + return obstacleCost + laneCost; +} + +float sampleDynamicCost(vec4 xytk, float time, float velocity, float acceleration) { + vec2 sl = xy2sl(xytk); + vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slDynamicObstacleGrid, 0).xy) / vec2(slGridCellSize) + 0.5; + float dynamicFrame = floor(time / dynamicFrameTime); + + float obstacleCost = texture(slDynamicObstacleGrid, vec3(slTexCoords, dynamicFrame)).r; + + if (obstacleCost > 0.75) return -1.0; // Infinite cost + + return step(0.25, obstacleCost) * obstacleHazardCost; +} + +float calculateAverageStaticCost(int numSamples) { + float averageStaticCost = 0.0; + + for (int i = 0; i < numSamples; i++) { + float cost = sampleStaticCost(pathSamples[i]); + + if (cost < 0.0) return cost; + + averageStaticCost += cost; + } + + averageStaticCost /= float(numSamples); + + return averageStaticCost; +} + +float calculateAverageDynamicCost(int numSamples, float pathLength, float initialTime, float initialVelocity, float acceleration, float abandonThreshold) { + float s = 0.0; + float ds = pathLength / float(numSamples - 1); + float averageDynamicCost = 0.0; + float maxVelocity = 0.0; + float maxLateralAcceleration = 0.0; + float numSamples_f = float(numSamples); + + for (int i = 0; i < numSamples; i++) { + vec4 pathSample = pathSamples[i]; // vec4(x-pos, y-pos, theta (rotation), kappa (curvature)) + + float velocitySq = 2.0 * acceleration * s + initialVelocity * initialVelocity; + float velocity = max(smallV, sqrt(max(0.0, velocitySq))); + maxVelocity = max(maxVelocity, velocity); + maxLateralAcceleration = max(maxLateralAcceleration, abs(pathSample.w * velocity * velocity)); + + float time = 2.0 * s / (initialVelocity + velocity) + initialTime; + + float dCurv = pathSampleCurvRates[i] * velocity; + if (dCurv > dCurvatureMax) return -1.0; + + float cost = sampleDynamicCost(pathSample, time, velocity, acceleration); + if (cost < 0.0) return cost; + + averageDynamicCost += cost; + if (averageDynamicCost / numSamples_f >= abandonThreshold) return -1.0; + + s += ds; + } + + averageDynamicCost /= numSamples_f; + + // Apply speeding penality if any velocity along the trajectory is over the speed limit + averageDynamicCost += step(speedLimit, maxVelocity) * speedLimitPenalty; + + // Apply hard acceleration/deceleration penalties if the acceleration/deceleration exceeds the soft limits + averageDynamicCost += step(accelerationProfiles[2] + 0.0001, acceleration) * hardAccelerationPenalty; + averageDynamicCost += (1.0 - step(accelerationProfiles[3], acceleration)) * hardDecelerationPenalty; + + // Penalize lateral acceleration + averageDynamicCost += step(softLateralAccelerationLimit, maxLateralAcceleration) * softLateralAccelerationPenalty; + averageDynamicCost += linearLateralAccelerationPenalty * maxLateralAcceleration; + + return averageDynamicCost; +} + +vec3 calculateAVT(int accelerationIndex, float initialVelocity, float initialTime, float pathLength) { + float initialVelocitySq = initialVelocity * initialVelocity; + float acceleration = calculateAcceleration(accelerationIndex, initialVelocitySq, pathLength); + + float finalVelocitySq = 2.0 * acceleration * pathLength + initialVelocitySq; + float finalVelocity = max(smallV, sqrt(max(0.0, finalVelocitySq))); + + float finalTime = initialTime; + + if (acceleration == 0.0) { + finalTime += pathLength / finalVelocity; + } else if (finalVelocitySq <= 0.0) { // Calculate final time if the vehicle stops before the end of the trajectory + float distanceLeft = pathLength - (smallV * smallV - initialVelocitySq) / (2.0 * acceleration); + finalTime += (finalVelocity - initialVelocity) / acceleration + distanceLeft / smallV; + } else { + finalTime += 2.0 * pathLength / (finalVelocity + initialVelocity); + } + + return vec3(acceleration, finalVelocity, finalTime); +} + +`; + +const SAMPLE_CUBIC_PATH_FN = ` + +int sampleCubicPath(vec4 start, vec4 end, vec4 cubicPathParams) { + float p0 = start.w; + float p1 = cubicPathParams.x; + float p2 = cubicPathParams.y; + float p3 = end.w; + float sG = cubicPathParams.z; + + if (sG <= 0.0) return 0; + + int numSamples = int(ceil(sG / pathSamplingStep)) + 1; + + float sG_2 = sG * sG; + float sG_3 = sG_2 * sG; + + float a = p0; + float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG; + float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2; + float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3; + + pathSamples[0] = start; + + float ds = sG / float(numSamples - 1); + float s = ds; + vec2 dxy = vec2(0); + vec2 prevCosSin = vec2(cos(start.z), sin(start.z)); + + for (int i = 1; i < numSamples; i++) { + float rot = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s + start.z; + float curv = ((d * s + c) * s + b) * s + a; + + vec2 cosSin = vec2(cos(rot), sin(rot)); + dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i); + + pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv); + pathSampleCurvRates[i] = b + s * (2.0 * c + 3.0 * d * s); + + s += ds; + prevCosSin = cosSin; + } + + return numSamples; +} + +`; + +const SAMPLE_QUINTIC_PATH_FN = ` + +int sampleQuinticPath(vec4 start, vec4 end, vec4 quinticPathParams) { + float p0 = start.w; + float p1 = dCurvVehicle; + float p2 = ddCurvVehicle; + float p3 = quinticPathParams.x; + float p4 = quinticPathParams.y; + float p5 = end.w; + float sG = quinticPathParams.z; + + if (sG <= 0.0) return 0; + + int numSamples = int(ceil(sG / pathSamplingStep)) + 1; + + float sG_2 = sG * sG; + float sG_3 = sG_2 * sG; + + float a = p0; + float b = p1; + float c = p2 / 2.0; + float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3; + 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); + 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); + + pathSamples[0] = start; + + float ds = sG / float(numSamples - 1); + float s = ds; + vec2 dxy = vec2(0); + vec2 prevCosSin = vec2(cos(start.z), sin(start.z)); + + for (int i = 1; i < numSamples; i++) { + 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; + float curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a; + + vec2 cosSin = vec2(cos(rot), sin(rot)); + dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i); + + pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv); + pathSampleCurvRates[i] = b + s * (2.0 * c + s * (3.0 * d + s * (4.0 * e + 5.0 * f * s))); + + s += ds; + prevCosSin = cosSin; + } + + return numSamples; +} + +`; + +const NUM_ACCELERATION_PROFILES = 8; +const NUM_VELOCITY_RANGES = 4; +const NUM_TIME_RANGES = 2; + +const SHARED_UNIFORMS = { + xyslMap: { type: 'outputTexture' }, + slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' }, + slDynamicObstacleGrid: { type: 'outputTexture', name: 'slDynamicObstacleGrid', textureType: '2DArray' }, + accelerationProfiles: { type: 'float', length: 5 }, + finalVelocityProfiles: { type: 'float', length: 3 }, + xyCenterPoint: { type: 'vec2' }, + xyGridCellSize: { type: 'float' }, + slCenterPoint: { type: 'vec2' }, + slGridCellSize: { type: 'float'}, + laneCenterLatitude: { type: 'float'}, + laneShoulderLatitude: { type: 'float'}, + laneCostSlope: { type: 'float'}, + lanePreference: { type: 'float' }, + lanePreferenceDiscount: { type: 'float' }, + obstacleHazardCost: { type: 'float' }, + speedLimit: { type: 'float' }, + speedLimitPenalty: { type: 'float' }, + hardAccelerationPenalty: { type: 'float' }, + hardDecelerationPenalty: { type: 'float' }, + softLateralAccelerationLimit: { type: 'float' }, + softLateralAccelerationPenalty: { type: 'float' }, + linearLateralAccelerationPenalty: { type: 'float' }, + dCurvatureMax: { type: 'float' }, + pathSamplingStep: { type: 'float' }, + rearAxleToCenter: { type: 'float' }, + dynamicFrameTime: { type: 'float' } +}; + +function buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime) { + return { + accelerationProfiles: [3.5, -6.5, 2.0, -3.0, 0], + finalVelocityProfiles: [0.999 * config.speedLimit, 1.0, 0.01], + xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y], + xyGridCellSize: config.xyGridCellSize, + slCenterPoint: [slCenterPoint.x, slCenterPoint.y], + slGridCellSize: config.slGridCellSize, + laneCenterLatitude: config.laneCenterLatitude, + laneShoulderLatitude: config.laneShoulderLatitude, + laneCostSlope: config.laneCostSlope, + lanePreference: config.lanePreference, + lanePreferenceDiscount: config.lanePreferenceDiscount, + obstacleHazardCost: config.obstacleHazardCost, + speedLimit: config.speedLimit, + speedLimitPenalty: config.speedLimitPenalty, + hardAccelerationPenalty: config.hardAccelerationPenalty, + hardDecelerationPenalty: config.hardDecelerationPenalty, + softLateralAccelerationLimit: config.softLateralAccelerationLimit, + softLateralAccelerationPenalty: config.softLateralAccelerationPenalty, + linearLateralAccelerationPenalty: config.linearLateralAccelerationPenalty, + dCurvatureMax: config.dCurvatureMax, + pathSamplingStep: config.pathSamplingStep, + rearAxleToCenter: config.rearAxleToCenter, + dynamicFrameTime: dynamicFrameTime + }; +} + +export { + SHARED_SHADER, + SAMPLE_CUBIC_PATH_FN, + SAMPLE_QUINTIC_PATH_FN, + + NUM_ACCELERATION_PROFILES, + NUM_VELOCITY_RANGES, + NUM_TIME_RANGES, + + SHARED_UNIFORMS, + buildUniformValues +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js new file mode 100644 index 0000000..ba27d9e --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js @@ -0,0 +1,269 @@ +// Config: +// num stations +// num latitudes +// station connectivity +// latitude connectivity +// +// Shared: +// lattice + +const OPTIMIZE_CUBIC_SHARED = ` + +const int NEWTON_ITERATIONS = 16; +const int RELAXATION_ITERATIONS = 16; +const float CONVERGENCE_ERROR = 0.01; + +// These two consts must stay in sync. +const int SIMPSONS_INTERVALS = 8; +//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); +const 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); + +const float PI = 3.1415926535897932384626433832795; +const float TWO_PI = PI + PI; + +const float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS); +const float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS); + +float wrapAngle(float angle) { + angle = mod(angle, TWO_PI); + if (angle <= -PI) return angle + TWO_PI; + else if (angle > PI) return angle - TWO_PI; + return angle; +} + +vec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float sG) { + float ds = sG / SIMPSONS_INTERVALS_F; + float sG_2 = sG * sG; + float sG_3 = sG_2 * sG; + + vec3 dX_p = vec3(0.0); + vec3 dY_p = vec3(0.0); + vec2 guess = vec2(0.0); + float s = 0.0; + + float theta, cosTheta, sinTheta; + vec3 dT_p; + + for (int i = 0; i <= SIMPSONS_INTERVALS; i++) { + float coeff = SIMPSONS_COEFFS[i]; + + float a = p0; + float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG; + float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2; + float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3; + + theta = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s; + cosTheta = cos(theta); + sinTheta = sin(theta); + + float s_sG = s / sG; + + dT_p = vec3( + // p1 + ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s, + + // p2 + ((-3.375 * s_sG + 6.0) * s_sG - 2.25) * s_sG * s, + + // sG + ((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 + ); + + dX_p -= coeff * sinTheta * dT_p; + dY_p += coeff * cosTheta * dT_p; + + guess += coeff * vec2(cosTheta, sinTheta); + + s += ds; + } + + float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0; + + vec3 delta; + delta.xy = goal.xy - guess * hOver3; + delta.z = wrapAngle(goal.z - theta); + + if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR) + return vec4(p1, p2, sG, 1.0); + + dX_p.xyz *= hOver3; + dY_p.xyz *= hOver3; + dX_p.z += cosTheta; + dY_p.z += sinTheta; + + mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p))); + + vec3 deltaP = invJacobian * delta; + vec4 params = vec4(p1, p2, sG, 0.0); + params.xyz += deltaP; + + return params; +} + +/* Input: + * start: (vec4) + * x: x position, + * y: y position, + * z: theta rotation, + * w: k curvature + * end: (vec4) + * x: x position, + * y: y position, + * z: theta rotation, + * w: k curvature + * + * Output: (vec4) + * x: p1, + * y: p2, + * z: sG, + * w: 1 if converged, 0 if not + */ + +vec4 optimize(vec4 start, vec4 end) { + // Translate and rotate start and end so that start is at the origin + float sinRot = sin(start.z); + float cosRot = cos(start.z); + + vec4 diff = end - start; + vec4 goal; + goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy; + goal.z = wrapAngle(diff.z); + goal.w = end.w; + + vec4 originalGoal = goal; + vec4 dGoal; + dGoal.x = 0.0; + dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F; + float dK0 = start.w / RELAXATION_ITERATIONS_F; + + // Relax the goal to (x, 0, 0, 0) + goal.yzw = vec3(0, 0, 0); + + // Relax the params to (0, 0, 0, 0, goal.x) + float p0 = 0.0; + float p1 = 0.0; + float p2 = 0.0; + float p3 = 0.0; + float sG = goal.x; + + if (sG < 0.1) return vec4(0.0); + + for (int i = 0; i < RELAXATION_ITERATIONS; i++) { + p0 += dK0; + p3 += dGoal.w; + goal += dGoal; + + vec4 result = iterate(goal, p0, p1, p2, p3, sG); + p1 = result.x; + p2 = result.y; + sG = result.z; + } + + goal = originalGoal; + + for (int i = 0; i < NEWTON_ITERATIONS; i++) { + vec4 result = iterate(goal, p0, p1, p2, p3, sG); + if (result.w == 1.0) { + result.w = step(0.0, result.z); + return result; + } + + p1 = result.x; + p2 = result.y; + sG = result.z; + } + + return vec4(p1, p2, sG, 0.0); +} + +`; + +const OPTIMIZE_CUBIC_KERNEL = OPTIMIZE_CUBIC_SHARED + ` + +// width: station * latitude index +// height: station_conn * lattice_conn +// +// lattice: +// width: latitudes +// height: stations + +vec4 kernel() { + ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize)); + + int endStation = indexes.x / numLatitudes; + int endLatitude = int(mod(float(indexes.x), float(numLatitudes))); + + int startStation = endStation - stationConnectivity + indexes.y / latitudeConnectivity; + int startLatitude = endLatitude - latitudeConnectivity / 2 + int(mod(float(indexes.y), float(latitudeConnectivity))); + + if (startStation < 0 || startStation >= numStations || startLatitude < 0 || startLatitude >= numLatitudes) + return vec4(0.0); + + vec4 start = texelFetch(lattice, ivec2(startLatitude, startStation), 0); + vec4 end = texelFetch(lattice, ivec2(endLatitude, endStation), 0); + + return optimize(start, end); +} + +`; + +const OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL = OPTIMIZE_CUBIC_SHARED + ` + +vec4 kernel() { + ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize)); + + vec4 start = vec4(0, 0, 0, curvVehicle); + vec4 end = texelFetch(lattice, indexes, 0); + + return optimize(start, end); +} + +`; + +export default { + setUp() { + return [ + { // Cubic paths between lattice nodes + kernel: OPTIMIZE_CUBIC_KERNEL, + output: { name: 'cubicPaths', read: true }, + uniforms: { + lattice: { type: 'sharedTexture' }, + numStations: { type: 'int' }, + numLatitudes: { type: 'int' }, + stationConnectivity: { type: 'int' }, + latitudeConnectivity: { type: 'int' } + } + }, + { // Cubic paths from vehicle to lattice nodes + kernel: OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL, + output: { name: 'cubicPathsFromVehicle', read: true }, + uniforms: { + lattice: { type: 'sharedTexture' }, + curvVehicle: { type: 'float' } + } + } + ] + }, + + update(config, pose) { + return [ + { // Cubic paths between lattice nodes + width: config.lattice.numStations * config.lattice.numLatitudes, + height: config.lattice.stationConnectivity * config.lattice.latitudeConnectivity, + uniforms: { + numStations: config.lattice.numStations, + numLatitudes: config.lattice.numLatitudes, + stationConnectivity: config.lattice.stationConnectivity, + latitudeConnectivity: config.lattice.latitudeConnectivity, + } + }, + { // Cubic paths from vehicle to lattice nodes + width: config.lattice.numLatitudes, + height: config.lattice.stationConnectivity, + uniforms: { + curvVehicle: pose.curv + } + } + ]; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js new file mode 100644 index 0000000..35901ac --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js @@ -0,0 +1,204 @@ +const OPTIMIZE_KERNEL = ` + +const int NEWTON_ITERATIONS = 32; +const int RELAXATION_ITERATIONS = 32; +const float CONVERGENCE_ERROR = 0.01; + +// These two consts must stay in sync. +const int SIMPSONS_INTERVALS = 8; +const 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); + +const float PI = 3.1415926535897932384626433832795; +const float TWO_PI = PI + PI; + +const float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS); +const float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS); + +float wrapAngle(float angle) { + angle = mod(angle, TWO_PI); + if (angle <= -PI) return angle + TWO_PI; + else if (angle > PI) return angle - TWO_PI; + return angle; +} + +vec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float p4, float p5, float sG) { + float ds = sG / SIMPSONS_INTERVALS_F; + float sG_2 = sG * sG; + float sG_3 = sG_2 * sG; + + vec3 dX_p = vec3(0.0); + vec3 dY_p = vec3(0.0); + vec2 guess = vec2(0.0); + float s = 0.0; + + float theta, cosTheta, sinTheta; + vec3 dT_p; + + for (int i = 0; i <= SIMPSONS_INTERVALS; i++) { + float coeff = SIMPSONS_COEFFS[i]; + + float a = p0; + float b = p1; + float c = p2 / 2.0; + float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3; + 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); + 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); + + theta = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s; + cosTheta = cos(theta); + sinTheta = sin(theta); + + float s_2 = s * s; + float s_sG = s / sG; + float s_sG_2 = s_sG * s_sG; + float s_sG_3 = s_sG_2 * s_sG; + float s_sG_4 = s_sG_3 * s_sG; + float s_sG_5 = s_sG_4 * s_sG; + + dT_p = vec3( + // p3 + ((20.25 * s_sG - 40.5) * s_sG + 20.25) * s_sG_3 * s, + + // p4 + ((-5.0625 * s_sG + 8.1) * s_sG - 2.53125) * s_sG_3 * s, + + // sG + (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 + ); + + dX_p -= coeff * sinTheta * dT_p; + dY_p += coeff * cosTheta * dT_p; + + guess += coeff * vec2(cosTheta, sinTheta); + + s += ds; + } + + float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0; + + vec3 delta; + delta.xy = goal.xy - guess * hOver3; + delta.z = wrapAngle(goal.z - theta); + + if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR) + return vec4(p3, p4, sG, 1.0); + + dX_p.xyz *= hOver3; + dY_p.xyz *= hOver3; + dX_p.z += cosTheta; + dY_p.z += sinTheta; + + mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p))); + + vec3 deltaP = invJacobian * delta; + vec4 params = vec4(p3, p4, sG, 0.0); + params.xyz += deltaP; + + return params; +} + +vec4 optimize(vec4 start, vec4 end) { + // Translate and rotate start and end so that start is at the origin + float sinRot = sin(start.z); + float cosRot = cos(start.z); + + vec4 diff = end - start; + vec4 goal; + goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy; + goal.z = wrapAngle(diff.z); + goal.w = end.w; + + vec4 originalGoal = goal; + vec4 dGoal; + dGoal.x = 0.0; + dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F; + float d_K0 = start.w / RELAXATION_ITERATIONS_F; + float d_dK0 = dCurvVehicle / RELAXATION_ITERATIONS_F; + float d_ddK0 = ddCurvVehicle / RELAXATION_ITERATIONS_F; + + // Relax the goal to (x, 0, 0, 0) + goal.yzw = vec3(0, 0, 0); + + // Relax the params to (0, 0, 0, 0, goal.x) + float p0 = 0.0; + float p1 = 0.0; + float p2 = 0.0; + float p3 = 0.0; + float p4 = 0.0; + float p5 = 0.0; + float sG = goal.x; + + if (sG < 0.1) return vec4(0.0); + + for (int i = 0; i < RELAXATION_ITERATIONS; i++) { + p0 += d_K0; + p1 += d_dK0; + p2 += d_ddK0; + p5 += dGoal.w; + goal += dGoal; + + vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG); + p3 = result.x; + p4 = result.y; + sG = result.z; + } + + goal = originalGoal; + + for (int i = 0; i < NEWTON_ITERATIONS; i++) { + vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG); + if (result.w == 1.0) { + result.w = step(0.0, result.z); + return result; + } + + p3 = result.x; + p4 = result.y; + sG = result.z; + } + + return vec4(p3, p4, sG, 0.0); +} + +vec4 kernel() { + ivec2 latticeIndexes = ivec2(kernelPosition * vec2(kernelSize)); + + vec4 start = vec4(0, 0, 0, curvVehicle); + vec4 end = texelFetch(lattice, latticeIndexes, 0); + + return optimize(start, end); +} + +`; + +// Quintic spiral path optimizer +// * Start of paths is the vehicle pose +// * x-pos, y-pos, and rotation aren't needed, since the lattice origin is the vehicle pose +// * So assume position and rotation are 0 +// * Ends of paths are all latitudes within the first (stationConnectivity) stations +export default { + setUp() { + return { + kernel: OPTIMIZE_KERNEL, + output: { name: 'quinticPathsFromVehicle', read: true }, + uniforms: { + lattice: { type: 'sharedTexture' }, + curvVehicle: { type: 'float' }, + dCurvVehicle: { type: 'float' }, + ddCurvVehicle: { type: 'float' } + } + }; + }, + + update(config, pose) { + return { + width: config.lattice.numLatitudes, + height: config.lattice.stationConnectivity, + uniforms: { + curvVehicle: pose.curv, + dCurvVehicle: pose.dCurv, + ddCurvVehicle: pose.ddCurv + } + }; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js new file mode 100644 index 0000000..37d14b6 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js @@ -0,0 +1,131 @@ +import { SHARED_SHADER, SAMPLE_CUBIC_PATH_FN, SAMPLE_QUINTIC_PATH_FN, NUM_ACCELERATION_PROFILES, SHARED_UNIFORMS, buildUniformValues } from "./graphSearchShared.js"; + +function fromVehiclePathCostsKernel(pathType) { + return SHARED_SHADER + (pathType == 'cubic' ? SAMPLE_CUBIC_PATH_FN : SAMPLE_QUINTIC_PATH_FN) + + +` + +/* Calculate cost of a {cubic|quintic} path from vehicle to (stationConnectivity * numLatitudes * numAccelerations) nodes + * width: numLatitudes + * height: station * numAccelerations + */ +vec4 kernel() { + ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize)); + + int latitude = indexes.x; + int station = indexes.y / numAccelerations; + int accelerationIndex = int(mod(float(indexes.y), float(numAccelerations))); + + vec4 pathStart = vec4(0, 0, 0, curvVehicle); + vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0); + + vec4 pathParams = texelFetch(pathsFromVehicle, ivec2(latitude, station), 0); + + // If the path didn't converge + if (pathParams.w == 0.0) return vec4(-1); + + int numSamples = ${pathType == 'cubic' ? 'sampleCubicPath' : 'sampleQuinticPath'}(pathStart, pathEnd, pathParams); + float pathLength = pathParams.z; + + if (numSamples < 2) return vec4(-1); + + float averageStaticCost = calculateAverageStaticCost(numSamples); + if (averageStaticCost < 0.0) return vec4(-1); + + int slIndex = station * kernelSize.x + latitude; + float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount; + averageStaticCost += hysteresisAdjustment; + + vec3 avt = calculateAVT(accelerationIndex, velocityVehicle, 0.0, pathLength); + float acceleration = avt.x; + float finalVelocity = avt.y; + float finalTime = avt.z; + + float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, 0.0, velocityVehicle, acceleration, 1.0 / 0.0); + if (averageDynamicCost < 0.0) return vec4(-1); + + averageDynamicCost += accelerationChangePenalty; + + // The cost of a trajectory is the average sample cost scaled by the path length + float totalCost = (averageStaticCost + averageDynamicCost + ${pathType == 'cubic' ? '(cubicPathPenalty * velocityVehicle * velocityVehicle)' : '0.0'}) * pathLength; + ${pathType != 'cubic' ? 'totalCost = -1.0;' : ''} + + return vec4(totalCost, finalVelocity, finalTime, ${pathType == 'cubic' ? '-2' : '-1'}); +} + +`; +} + +export default { + setUp() { + return [ + { + kernel: fromVehiclePathCostsKernel('cubic'), + output: { name: 'cubicPathFromVehicleCosts' }, + uniforms: Object.assign({}, SHARED_UNIFORMS, { + lattice: { type: 'sharedTexture' }, + pathsFromVehicle: { type: 'outputTexture', name: 'cubicPathsFromVehicle' }, + firstLatticePoint: { type: 'int' }, + secondLatticePoint: { type: 'int' }, + velocityVehicle: { type: 'float' }, + curvVehicle: { type: 'float' }, + numAccelerations: { type: 'int' }, + cubicPathPenalty: { type: 'float' }, + hysteresisDiscount: { type: 'float' }, + accelerationChangePenalty: { type: 'float' } + }) + }, + { + kernel: fromVehiclePathCostsKernel('quintic'), + output: { name: 'quinticPathFromVehicleCosts' }, + uniforms: Object.assign({}, SHARED_UNIFORMS, { + lattice: { type: 'sharedTexture' }, + pathsFromVehicle: { type: 'outputTexture', name: 'quinticPathsFromVehicle' }, + firstLatticePoint: { type: 'int' }, + secondLatticePoint: { type: 'int' }, + velocityVehicle: { type: 'float' }, + curvVehicle: { type: 'float' }, + dCurvVehicle: { type: 'float' }, + ddCurvVehicle: { type: 'float' }, + numAccelerations: { type: 'int' }, + hysteresisDiscount: { type: 'float' }, + accelerationChangePenalty: { type: 'float' } + }) + } + ]; + }, + + update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) { + return [ + { + width: config.lattice.numLatitudes, + height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES, + uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), { + firstLatticePoint: firstLatticePoint, + secondLatticePoint: secondLatticePoint, + velocityVehicle: pose.velocity, + curvVehicle: pose.curv, + numAccelerations: NUM_ACCELERATION_PROFILES, + cubicPathPenalty: config.cubicPathPenalty, + hysteresisDiscount: config.hysteresisDiscount, + accelerationChangePenalty: config.accelerationChangePenalty + }) + }, + { + width: config.lattice.numLatitudes, + height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES, + uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), { + firstLatticePoint: firstLatticePoint, + secondLatticePoint: secondLatticePoint, + velocityVehicle: pose.velocity, + curvVehicle: pose.curv, + dCurvVehicle: pose.dCurv, + ddCurvVehicle: pose.ddCurv, + numAccelerations: NUM_ACCELERATION_PROFILES, + hysteresisDiscount: config.hysteresisDiscount, + accelerationChangePenalty: config.accelerationChangePenalty + }) + } + ]; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js new file mode 100644 index 0000000..5bdeaed --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js @@ -0,0 +1,115 @@ +const DYNAMIC_OBSTACLE_VERTEX_SHADER = `#version 300 es +uniform mat3 xform; +in vec3 position; +out float color; + +void main(void) { + gl_Position = vec4((xform * vec3(position.xy, 1)).xy, position.z, 1); + + // The z coordinate is 0.25 for collision zone and 0.75 for hazard zone, + // so that the collision zone is drawn on top. + // Convert this to 1.0 for collision zone, 0.5 for hazard zone + color = (1.0 - step(0.5, position.z)) * 0.5 + 0.5; +} +`; + +const DYNAMIC_OBSTACLE_KERNEL = ` + in float color; + + vec4 kernel() { + return vec4(color, 0, 0, 1); + } +`; + +let obstacleVertices; +let obstacleXform; +const numDynamicFrames = 20; + +// Draw dynamic obstacle triangles to SL-space obstacle grid +export default { + setUp() { + return { + kernel: DYNAMIC_OBSTACLE_KERNEL, + vertexShader: DYNAMIC_OBSTACLE_VERTEX_SHADER, + output: { name: 'slDynamicObstacleGrid', textureType: '2DArray', depth: numDynamicFrames }, + draw: (gpgpu, program) => { + const gl = gpgpu.gl; + + gl.enable(gl.DEPTH_TEST); + + const renderbuffer = gl.createRenderbuffer(); + gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); + gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, program.inputWidth, program.inputHeight); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer); + + for (let frame = 0; frame < numDynamicFrames; frame++) { + gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, program.outputTexture, 0, frame); + const frameBufferStatus = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE); + if (!frameBufferStatus) + throw new Error('Error attaching float texture to framebuffer. Your device is probably incompatible.'); + + gl.clearColor(0, 0, 0, 0); + gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); + + if (obstacleVertices[frame].length > 0) { + const buf = gl.createBuffer(); + + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices[frame], gl.STATIC_DRAW); + gl.enableVertexAttribArray(program.positionLocation); + gl.vertexAttribPointer(program.positionLocation, 3, gl.FLOAT, false, 0, 0); + + const xformLocation = gl.getUniformLocation(program.glProgram, 'xform'); + gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements); + + gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices[frame].length / 3); + + if (frame == 0) { + const obstacleGrid = new Float32Array(program.inputWidth * program.inputHeight * 4); + gl.readPixels(0, 0, program.inputWidth, program.inputHeight, gl.RGBA, gl.FLOAT, obstacleGrid); + gpgpu._dynamicObstacleGrid = obstacleGrid; + } + + gl.deleteBuffer(buf); + } + } + + gl.bindRenderbuffer(gl.RENDERBUFFER, null); + gl.deleteRenderbuffer(renderbuffer); + gl.disable(gl.DEPTH_TEST); + } + }; + }, + + update(config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles) { + obstacleVertices = []; + + let time = startTime; + for (let frame = 0; frame < numDynamicFrames; frame++) { + const vertices = Array.prototype.concat.apply([], dynamicObstacles.map(o => o.verticesInTimeRange(time, time + dynamicFrameTime, config))); + obstacleVertices.push(new Float32Array(vertices)); + time += dynamicFrameTime; + } + + const translate = new THREE.Matrix3(); + translate.set( + 1, 0, -slCenterPoint.x - vehicleStation, + 0, 1, -slCenterPoint.y, + 0, 0, 1 + ); + + const scale = new THREE.Matrix3(); + scale.set( + 2 / (slWidth * config.slGridCellSize), 0, 0, + 0, 2 / (slHeight * config.slGridCellSize), 0, + 0, 0, 1 + ); + + obstacleXform = scale.multiply(translate); + + return { + width: slWidth, + height: slHeight + } + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js new file mode 100644 index 0000000..2694146 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js @@ -0,0 +1,51 @@ +const SL_OBSTACLE_KERNEL = ` + +vec4 kernel() { + float centerlineWidth = float(textureSize(centerline, 0).x); + + vec2 sl = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(slGridCellSize) + slCenterPoint; + float centerlineCoord = sl.x / centerlineStationInterval / centerlineWidth * (centerlineWidth - 1.0) / centerlineWidth + (0.5 / centerlineWidth); + if (centerlineCoord < 0.0 || centerlineCoord > 1.0) return vec4(0); + + vec3 centerlineSample = texture(centerline, vec2(centerlineCoord, 0)).xyz; + float perpindicular = centerlineSample.z + radians(90.0); + vec2 xy = centerlineSample.xy + sl.yy * vec2(cos(perpindicular), sin(perpindicular)); + + vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyObstacleGrid, 0)) / vec2(xyGridCellSize) + 0.5; + return texture(xyObstacleGrid, xyTexCoords); +} + +`; + +// Convert XY-space obstacle grid to SL-space obstacle grid +export default { + setUp() { + return { + kernel: SL_OBSTACLE_KERNEL, + output: { name: 'slObstacleGrid' }, + uniforms: { + xyObstacleGrid: { type: 'outputTexture' }, + slGridCellSize: { type: 'float' }, + xyGridCellSize: { type: 'float' }, + slCenterPoint: { type: 'vec2' }, + xyCenterPoint: { type: 'vec2' }, + centerlineStationInterval: { type: 'float' }, + centerline: { type: 'sharedTexture' } + } + } + }, + + update(config, slWidth, slHeight, slCenterPoint, xyCenterPoint) { + return { + width: slWidth, + height: slHeight, + uniforms: { + slGridCellSize: config.slGridCellSize, + xyGridCellSize: config.xyGridCellSize, + slCenterPoint: [slCenterPoint.x, slCenterPoint.y], + xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y], + centerlineStationInterval: config.centerlineStationInterval + } + } + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js new file mode 100644 index 0000000..6c9acaa --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js @@ -0,0 +1,72 @@ +const SL_OBSTACLE_DILATION_KERNEL = ` + +// TODO: test performance of returning early if non-zero pixel found +vec4 kernel() { + float val = 0.0; + + for (int d = 0; d <= collisionDilation; d++) { + val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r); + val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r); + } + + for (int d = collisionDilation + 1; d <= collisionDilation + hazardDilation; d++) { + val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r * 0.5); + val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r * 0.5); + } + + val = max(val, step(0.1, val) * 0.5); + + return vec4(val, 0, 0, 1); +} + +`; + +export default { + setUp() { + return [ + { // SL-space obstacle grid S dilation + kernel: SL_OBSTACLE_DILATION_KERNEL, + output: { name: 'slObstacleGridStationDilated' }, + uniforms: { + slObstacleGrid: { type: 'outputTexture' }, + delta: { type: 'vec2' }, + collisionDilation: { type: 'int' }, + hazardDilation: { type: 'int' } + } + }, + { // SL-space obstacle grid L dilation + kernel: SL_OBSTACLE_DILATION_KERNEL, + output: { name: 'slObstacleGridDilated' }, + uniforms: { + slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridStationDilated' }, + delta: { type: 'vec2' }, + collisionDilation: { type: 'int' }, + hazardDilation: { type: 'int' } + } + } + ]; + }, + + update(config, slWidth, slHeight) { + return [ + { // SL-space obstacle grid S dilation + width: slWidth, + height: slHeight, + uniforms: { + delta: [1 / slWidth, 0], + collisionDilation: Math.ceil(config.collisionDilationS / config.slGridCellSize), + hazardDilation: Math.ceil(config.hazardDilationS / config.slGridCellSize) + } + }, + { // SL-space obstacle grid L dilation + width: slWidth, + height: slHeight, + uniforms: { + delta: [0, 1 / slHeight], + collisionDilation: Math.ceil(config.collisionDilationL / config.slGridCellSize), + hazardDilation: Math.ceil(config.hazardDilationL / config.slGridCellSize) + } + } + ]; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js new file mode 100644 index 0000000..0b4eb18 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js @@ -0,0 +1,44 @@ +const XY_OBSTACLE_COST_KERNEL = ` + +vec4 kernel() { + vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint; + + vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5; + vec2 sl = texture(xyslMap, xyTexCoords).xy; + + vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5; + return texture(slObstacleGrid, slTexCoords); +} + +`; + +// Build XY obstacle costs using XYSL map +export default { + setUp() { + return { + kernel: XY_OBSTACLE_COST_KERNEL, + output: { name: 'xyObstacleCostGrid', read: true }, + uniforms: { + xyslMap: { type: 'outputTexture' }, + slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' }, + xyCenterPoint: { type: 'vec2' }, + xyGridCellSize: { type: 'float'}, + slCenterPoint: { type: 'vec2' }, + slGridCellSize: { type: 'float'} + } + }; + }, + + update(config, xyWidth, xyHeight, xyCenterPoint, slCenterPoint) { + return { + width: xyWidth, + height: xyHeight, + uniforms: { + xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y], + xyGridCellSize: config.xyGridCellSize, + slCenterPoint: [slCenterPoint.x, slCenterPoint.y], + slGridCellSize: config.slGridCellSize + } + }; + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js new file mode 100644 index 0000000..2c43835 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js @@ -0,0 +1,75 @@ +const OBSTACLE_VERTEX_SHADER = `#version 300 es +uniform mat3 xform; +in vec2 position; + +void main(void) { + gl_Position = vec4((xform * vec3(position, 1)).xy, 0, 1); +} +`; + +const OBSTACLE_KERNEL = ` + vec4 kernel() { + return vec4(1, 0, 0, 1); + } +`; + +let obstacleVertices; +let obstacleXform; + +// Draw obstacle triangles to XY-space obstacle grid +export default { + setUp() { + return { + kernel: OBSTACLE_KERNEL, + vertexShader: OBSTACLE_VERTEX_SHADER, + output: { name: 'xyObstacleGrid' }, + draw: (gpgpu, program) => { + const gl = gpgpu.gl; + + gl.clearColor(0, 0, 0, 0); + gl.clear(gl.COLOR_BUFFER_BIT); + + if (obstacleVertices.length > 0) { + const buf = gl.createBuffer(); + + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices, gl.STATIC_DRAW); + gl.enableVertexAttribArray(program.positionLocation); + gl.vertexAttribPointer(program.positionLocation, 2, gl.FLOAT, false, 0, 0); + + const xformLocation = gl.getUniformLocation(program.glProgram, 'xform'); + gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements); + + gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices.length / 2); + + gl.deleteBuffer(buf); + } + } + }; + }, + + update(config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, obstacles) { + obstacleVertices = new Float32Array(Array.prototype.concat.apply([], obstacles.map(o => o.vertices))); + + const translate = new THREE.Matrix3(); + translate.set( + 1, 0, -xyCenterPoint.x, + 0, 1, -xyCenterPoint.y, + 0, 0, 1 + ); + + const scale = new THREE.Matrix3(); + scale.set( + 2 / (xyWidth * config.xyGridCellSize), 0, 0, + 0, 2 / (xyHeight * config.xyGridCellSize), 0, + 0, 0, 1 + ); + + obstacleXform = scale.multiply(translate).multiply(vehicleXform); + + return { + width: xyWidth, + height: xyHeight + } + } +} diff --git a/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyslMap.js b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyslMap.js new file mode 100644 index 0000000..cb61ba1 --- /dev/null +++ b/seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyslMap.js @@ -0,0 +1,88 @@ +const XYSL_MAP_KERNEL = ` + +vec4 kernel() { + vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint; + + int numSamples = textureSize(centerline, 0).x; + int closest = 0; + float closestDist = distance(xy, texelFetch(centerline, ivec2(0, 0), 0).xy); + for (int i = 1; i < numSamples; i++) { + float dist = distance(xy, texelFetch(centerline, ivec2(i, 0), 0).xy); + if (dist < closestDist) { + closestDist = dist; + closest = i; + } + } + + vec2 closestPos = texelFetch(centerline, ivec2(closest, 0), 0).xy; + vec2 prev, next; + int prevIndex, nextIndex; + + if (closest == 0) { + prevIndex = 0; + nextIndex = 1; + prev = closestPos; + next = texelFetch(centerline, ivec2(1, 0), 0).xy; + } else if (closest == numSamples - 1) { + prevIndex = closest - 1; + nextIndex = closest; + prev = texelFetch(centerline, ivec2(prevIndex, 0), 0).xy; + next = closestPos; + } else { + vec2 before = texelFetch(centerline, ivec2(closest - 1, 0), 0).xy; + vec2 after = texelFetch(centerline, ivec2(closest + 1, 0), 0).xy; + + if (distance(before, xy) < distance(after, xy)) { + prevIndex = closest - 1; + nextIndex = closest; + prev = before; + next = closestPos; + } else { + prevIndex = closest; + nextIndex = closest + 1; + prev = closestPos; + next = after; + } + } + + float dist = distance(prev, next); + float progress = clamp(dot(xy - prev, next - prev) / dist / dist, 0.0, 1.0); + vec2 projectedPos = (next - prev) * vec2(progress) + prev; + + return vec4( + (float(prevIndex) + progress) * centerlineStationInterval, + sign(determinant(mat2(next - prev, xy - prev))) * distance(xy, projectedPos), + 0, + 0 + ); +} + +`; + +// Build XY-SL map +export default { + setUp() { + return { + kernel: XYSL_MAP_KERNEL, + output: { name: 'xyslMap', filter: 'linear' }, + uniforms: { + centerline: { type: 'sharedTexture' }, + xyCenterPoint: { type: 'vec2' }, + xyGridCellSize: { type: 'float'}, + centerlineStationInterval: { type: 'float'} + } + }; + }, + + update(config, xyWidth, xyHeight, xyCenterPoint) { + return { + width: xyWidth, + height: xyHeight, + uniforms: { + xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y], + xyGridCellSize: config.xyGridCellSize, + centerlineStationInterval: config.centerlineStationInterval + } + }; + } +} diff --git a/seminar06-planning/simulator/js/objects/BufferGeometryUtils.js b/seminar06-planning/simulator/js/objects/BufferGeometryUtils.js new file mode 100644 index 0000000..f620433 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/BufferGeometryUtils.js @@ -0,0 +1,1371 @@ +import { + BufferAttribute, + BufferGeometry, + Float32BufferAttribute, + InstancedBufferAttribute, + InterleavedBuffer, + InterleavedBufferAttribute, + TriangleFanDrawMode, + TriangleStripDrawMode, + TrianglesDrawMode, + Vector3, +} from 'three'; + +function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) { + + if ( ! MikkTSpace || ! MikkTSpace.isReady ) { + + throw new Error( 'BufferGeometryUtils: Initialized MikkTSpace library required.' ); + + } + + if ( ! geometry.hasAttribute( 'position' ) || ! geometry.hasAttribute( 'normal' ) || ! geometry.hasAttribute( 'uv' ) ) { + + throw new Error( 'BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' ); + + } + + function getAttributeArray( attribute ) { + + if ( attribute.normalized || attribute.isInterleavedBufferAttribute ) { + + const dstArray = new Float32Array( attribute.count * attribute.itemSize ); + + for ( let i = 0, j = 0; i < attribute.count; i ++ ) { + + dstArray[ j ++ ] = attribute.getX( i ); + dstArray[ j ++ ] = attribute.getY( i ); + + if ( attribute.itemSize > 2 ) { + + dstArray[ j ++ ] = attribute.getZ( i ); + + } + + } + + return dstArray; + + } + + if ( attribute.array instanceof Float32Array ) { + + return attribute.array; + + } + + return new Float32Array( attribute.array ); + + } + + // MikkTSpace algorithm requires non-indexed input. + + const _geometry = geometry.index ? geometry.toNonIndexed() : geometry; + + // Compute vertex tangents. + + const tangents = MikkTSpace.generateTangents( + + getAttributeArray( _geometry.attributes.position ), + getAttributeArray( _geometry.attributes.normal ), + getAttributeArray( _geometry.attributes.uv ) + + ); + + // Texture coordinate convention of glTF differs from the apparent + // default of the MikkTSpace library; .w component must be flipped. + + if ( negateSign ) { + + for ( let i = 3; i < tangents.length; i += 4 ) { + + tangents[ i ] *= - 1; + + } + + } + + // + + _geometry.setAttribute( 'tangent', new BufferAttribute( tangents, 4 ) ); + + if ( geometry !== _geometry ) { + + geometry.copy( _geometry ); + + } + + return geometry; + +} + +/** + * @param {Array} geometries + * @param {Boolean} useGroups + * @return {BufferGeometry} + */ +function mergeGeometries( geometries, useGroups = false ) { + + const isIndexed = geometries[ 0 ].index !== null; + + const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) ); + const morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) ); + + const attributes = {}; + const morphAttributes = {}; + + const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative; + + const mergedGeometry = new BufferGeometry(); + + let offset = 0; + + for ( let i = 0; i < geometries.length; ++ i ) { + + const geometry = geometries[ i ]; + let attributesCount = 0; + + // ensure that all geometries are indexed, or none + + if ( isIndexed !== ( geometry.index !== null ) ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' ); + return null; + + } + + // gather attributes, exit early if they're different + + for ( const name in geometry.attributes ) { + + if ( ! attributesUsed.has( name ) ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' ); + return null; + + } + + if ( attributes[ name ] === undefined ) attributes[ name ] = []; + + attributes[ name ].push( geometry.attributes[ name ] ); + + attributesCount ++; + + } + + // ensure geometries have the same number of attributes + + if ( attributesCount !== attributesUsed.size ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' ); + return null; + + } + + // gather morph attributes, exit early if they're different + + if ( morphTargetsRelative !== geometry.morphTargetsRelative ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' ); + return null; + + } + + for ( const name in geometry.morphAttributes ) { + + if ( ! morphAttributesUsed.has( name ) ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphAttributes must be consistent throughout all geometries.' ); + return null; + + } + + if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = []; + + morphAttributes[ name ].push( geometry.morphAttributes[ name ] ); + + } + + if ( useGroups ) { + + let count; + + if ( isIndexed ) { + + count = geometry.index.count; + + } else if ( geometry.attributes.position !== undefined ) { + + count = geometry.attributes.position.count; + + } else { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' ); + return null; + + } + + mergedGeometry.addGroup( offset, count, i ); + + offset += count; + + } + + } + + // merge indices + + if ( isIndexed ) { + + let indexOffset = 0; + const mergedIndex = []; + + for ( let i = 0; i < geometries.length; ++ i ) { + + const index = geometries[ i ].index; + + for ( let j = 0; j < index.count; ++ j ) { + + mergedIndex.push( index.getX( j ) + indexOffset ); + + } + + indexOffset += geometries[ i ].attributes.position.count; + + } + + mergedGeometry.setIndex( mergedIndex ); + + } + + // merge attributes + + for ( const name in attributes ) { + + const mergedAttribute = mergeAttributes( attributes[ name ] ); + + if ( ! mergedAttribute ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' ); + return null; + + } + + mergedGeometry.setAttribute( name, mergedAttribute ); + + } + + // merge morph attributes + + for ( const name in morphAttributes ) { + + const numMorphTargets = morphAttributes[ name ][ 0 ].length; + + if ( numMorphTargets === 0 ) break; + + mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {}; + mergedGeometry.morphAttributes[ name ] = []; + + for ( let i = 0; i < numMorphTargets; ++ i ) { + + const morphAttributesToMerge = []; + + for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) { + + morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] ); + + } + + const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge ); + + if ( ! mergedMorphAttribute ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' ); + return null; + + } + + mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute ); + + } + + } + + return mergedGeometry; + +} + +/** + * @param {Array} attributes + * @return {BufferAttribute} + */ +function mergeAttributes( attributes ) { + + let TypedArray; + let itemSize; + let normalized; + let gpuType = - 1; + let arrayLength = 0; + + for ( let i = 0; i < attributes.length; ++ i ) { + + const attribute = attributes[ i ]; + + if ( TypedArray === undefined ) TypedArray = attribute.array.constructor; + if ( TypedArray !== attribute.array.constructor ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' ); + return null; + + } + + if ( itemSize === undefined ) itemSize = attribute.itemSize; + if ( itemSize !== attribute.itemSize ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' ); + return null; + + } + + if ( normalized === undefined ) normalized = attribute.normalized; + if ( normalized !== attribute.normalized ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' ); + return null; + + } + + if ( gpuType === - 1 ) gpuType = attribute.gpuType; + if ( gpuType !== attribute.gpuType ) { + + console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' ); + return null; + + } + + arrayLength += attribute.count * itemSize; + + } + + const array = new TypedArray( arrayLength ); + const result = new BufferAttribute( array, itemSize, normalized ); + let offset = 0; + + for ( let i = 0; i < attributes.length; ++ i ) { + + const attribute = attributes[ i ]; + if ( attribute.isInterleavedBufferAttribute ) { + + const tupleOffset = offset / itemSize; + for ( let j = 0, l = attribute.count; j < l; j ++ ) { + + for ( let c = 0; c < itemSize; c ++ ) { + + const value = attribute.getComponent( j, c ); + result.setComponent( j + tupleOffset, c, value ); + + } + + } + + } else { + + array.set( attribute.array, offset ); + + } + + offset += attribute.count * itemSize; + + } + + if ( gpuType !== undefined ) { + + result.gpuType = gpuType; + + } + + return result; + +} + +/** + * @param {BufferAttribute} + * @return {BufferAttribute} + */ +export function deepCloneAttribute( attribute ) { + + if ( attribute.isInstancedInterleavedBufferAttribute || attribute.isInterleavedBufferAttribute ) { + + return deinterleaveAttribute( attribute ); + + } + + if ( attribute.isInstancedBufferAttribute ) { + + return new InstancedBufferAttribute().copy( attribute ); + + } + + return new BufferAttribute().copy( attribute ); + +} + +/** + * @param {Array} attributes + * @return {Array} + */ +function interleaveAttributes( attributes ) { + + // Interleaves the provided attributes into an InterleavedBuffer and returns + // a set of InterleavedBufferAttributes for each attribute + let TypedArray; + let arrayLength = 0; + let stride = 0; + + // calculate the length and type of the interleavedBuffer + for ( let i = 0, l = attributes.length; i < l; ++ i ) { + + const attribute = attributes[ i ]; + + if ( TypedArray === undefined ) TypedArray = attribute.array.constructor; + if ( TypedArray !== attribute.array.constructor ) { + + console.error( 'AttributeBuffers of different types cannot be interleaved' ); + return null; + + } + + arrayLength += attribute.array.length; + stride += attribute.itemSize; + + } + + // Create the set of buffer attributes + const interleavedBuffer = new InterleavedBuffer( new TypedArray( arrayLength ), stride ); + let offset = 0; + const res = []; + const getters = [ 'getX', 'getY', 'getZ', 'getW' ]; + const setters = [ 'setX', 'setY', 'setZ', 'setW' ]; + + for ( let j = 0, l = attributes.length; j < l; j ++ ) { + + const attribute = attributes[ j ]; + const itemSize = attribute.itemSize; + const count = attribute.count; + const iba = new InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, attribute.normalized ); + res.push( iba ); + + offset += itemSize; + + // Move the data for each attribute into the new interleavedBuffer + // at the appropriate offset + for ( let c = 0; c < count; c ++ ) { + + for ( let k = 0; k < itemSize; k ++ ) { + + iba[ setters[ k ] ]( c, attribute[ getters[ k ] ]( c ) ); + + } + + } + + } + + return res; + +} + +// returns a new, non-interleaved version of the provided attribute +export function deinterleaveAttribute( attribute ) { + + const cons = attribute.data.array.constructor; + const count = attribute.count; + const itemSize = attribute.itemSize; + const normalized = attribute.normalized; + + const array = new cons( count * itemSize ); + let newAttribute; + if ( attribute.isInstancedInterleavedBufferAttribute ) { + + newAttribute = new InstancedBufferAttribute( array, itemSize, normalized, attribute.meshPerAttribute ); + + } else { + + newAttribute = new BufferAttribute( array, itemSize, normalized ); + + } + + for ( let i = 0; i < count; i ++ ) { + + newAttribute.setX( i, attribute.getX( i ) ); + + if ( itemSize >= 2 ) { + + newAttribute.setY( i, attribute.getY( i ) ); + + } + + if ( itemSize >= 3 ) { + + newAttribute.setZ( i, attribute.getZ( i ) ); + + } + + if ( itemSize >= 4 ) { + + newAttribute.setW( i, attribute.getW( i ) ); + + } + + } + + return newAttribute; + +} + +// deinterleaves all attributes on the geometry +export function deinterleaveGeometry( geometry ) { + + const attributes = geometry.attributes; + const morphTargets = geometry.morphTargets; + const attrMap = new Map(); + + for ( const key in attributes ) { + + const attr = attributes[ key ]; + if ( attr.isInterleavedBufferAttribute ) { + + if ( ! attrMap.has( attr ) ) { + + attrMap.set( attr, deinterleaveAttribute( attr ) ); + + } + + attributes[ key ] = attrMap.get( attr ); + + } + + } + + for ( const key in morphTargets ) { + + const attr = morphTargets[ key ]; + if ( attr.isInterleavedBufferAttribute ) { + + if ( ! attrMap.has( attr ) ) { + + attrMap.set( attr, deinterleaveAttribute( attr ) ); + + } + + morphTargets[ key ] = attrMap.get( attr ); + + } + + } + +} + +/** + * @param {BufferGeometry} geometry + * @return {number} + */ +function estimateBytesUsed( geometry ) { + + // Return the estimated memory used by this geometry in bytes + // Calculate using itemSize, count, and BYTES_PER_ELEMENT to account + // for InterleavedBufferAttributes. + let mem = 0; + for ( const name in geometry.attributes ) { + + const attr = geometry.getAttribute( name ); + mem += attr.count * attr.itemSize * attr.array.BYTES_PER_ELEMENT; + + } + + const indices = geometry.getIndex(); + mem += indices ? indices.count * indices.itemSize * indices.array.BYTES_PER_ELEMENT : 0; + return mem; + +} + +/** + * @param {BufferGeometry} geometry + * @param {number} tolerance + * @return {BufferGeometry} + */ +function mergeVertices( geometry, tolerance = 1e-4 ) { + + tolerance = Math.max( tolerance, Number.EPSILON ); + + // Generate an index buffer if the geometry doesn't have one, or optimize it + // if it's already available. + const hashToIndex = {}; + const indices = geometry.getIndex(); + const positions = geometry.getAttribute( 'position' ); + const vertexCount = indices ? indices.count : positions.count; + + // next value for triangle indices + let nextIndex = 0; + + // attributes and new attribute arrays + const attributeNames = Object.keys( geometry.attributes ); + const tmpAttributes = {}; + const tmpMorphAttributes = {}; + const newIndices = []; + const getters = [ 'getX', 'getY', 'getZ', 'getW' ]; + const setters = [ 'setX', 'setY', 'setZ', 'setW' ]; + + // Initialize the arrays, allocating space conservatively. Extra + // space will be trimmed in the last step. + for ( let i = 0, l = attributeNames.length; i < l; i ++ ) { + + const name = attributeNames[ i ]; + const attr = geometry.attributes[ name ]; + + tmpAttributes[ name ] = new BufferAttribute( + new attr.array.constructor( attr.count * attr.itemSize ), + attr.itemSize, + attr.normalized + ); + + const morphAttr = geometry.morphAttributes[ name ]; + if ( morphAttr ) { + + tmpMorphAttributes[ name ] = new BufferAttribute( + new morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize ), + morphAttr.itemSize, + morphAttr.normalized + ); + + } + + } + + // convert the error tolerance to an amount of decimal places to truncate to + const halfTolerance = tolerance * 0.5; + const exponent = Math.log10( 1 / tolerance ); + const hashMultiplier = Math.pow( 10, exponent ); + const hashAdditive = halfTolerance * hashMultiplier; + for ( let i = 0; i < vertexCount; i ++ ) { + + const index = indices ? indices.getX( i ) : i; + + // Generate a hash for the vertex attributes at the current index 'i' + let hash = ''; + for ( let j = 0, l = attributeNames.length; j < l; j ++ ) { + + const name = attributeNames[ j ]; + const attribute = geometry.getAttribute( name ); + const itemSize = attribute.itemSize; + + for ( let k = 0; k < itemSize; k ++ ) { + + // double tilde truncates the decimal value + hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * hashMultiplier + hashAdditive ) },`; + + } + + } + + // Add another reference to the vertex if it's already + // used by another index + if ( hash in hashToIndex ) { + + newIndices.push( hashToIndex[ hash ] ); + + } else { + + // copy data to the new index in the temporary attributes + for ( let j = 0, l = attributeNames.length; j < l; j ++ ) { + + const name = attributeNames[ j ]; + const attribute = geometry.getAttribute( name ); + const morphAttr = geometry.morphAttributes[ name ]; + const itemSize = attribute.itemSize; + const newarray = tmpAttributes[ name ]; + const newMorphArrays = tmpMorphAttributes[ name ]; + + for ( let k = 0; k < itemSize; k ++ ) { + + const getterFunc = getters[ k ]; + const setterFunc = setters[ k ]; + newarray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) ); + + if ( morphAttr ) { + + for ( let m = 0, ml = morphAttr.length; m < ml; m ++ ) { + + newMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttr[ m ][ getterFunc ]( index ) ); + + } + + } + + } + + } + + hashToIndex[ hash ] = nextIndex; + newIndices.push( nextIndex ); + nextIndex ++; + + } + + } + + // generate result BufferGeometry + const result = geometry.clone(); + for ( const name in geometry.attributes ) { + + const tmpAttribute = tmpAttributes[ name ]; + + result.setAttribute( name, new BufferAttribute( + tmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ), + tmpAttribute.itemSize, + tmpAttribute.normalized, + ) ); + + if ( ! ( name in tmpMorphAttributes ) ) continue; + + for ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) { + + const tmpMorphAttribute = tmpMorphAttributes[ name ][ j ]; + + result.morphAttributes[ name ][ j ] = new BufferAttribute( + tmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ), + tmpMorphAttribute.itemSize, + tmpMorphAttribute.normalized, + ); + + } + + } + + // indices + + result.setIndex( newIndices ); + + return result; + +} + +/** + * @param {BufferGeometry} geometry + * @param {number} drawMode + * @return {BufferGeometry} + */ +function toTrianglesDrawMode( geometry, drawMode ) { + + if ( drawMode === TrianglesDrawMode ) { + + console.warn( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.' ); + return geometry; + + } + + if ( drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode ) { + + let index = geometry.getIndex(); + + // generate index if not present + + if ( index === null ) { + + const indices = []; + + const position = geometry.getAttribute( 'position' ); + + if ( position !== undefined ) { + + for ( let i = 0; i < position.count; i ++ ) { + + indices.push( i ); + + } + + geometry.setIndex( indices ); + index = geometry.getIndex(); + + } else { + + console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' ); + return geometry; + + } + + } + + // + + const numberOfTriangles = index.count - 2; + const newIndices = []; + + if ( drawMode === TriangleFanDrawMode ) { + + // gl.TRIANGLE_FAN + + for ( let i = 1; i <= numberOfTriangles; i ++ ) { + + newIndices.push( index.getX( 0 ) ); + newIndices.push( index.getX( i ) ); + newIndices.push( index.getX( i + 1 ) ); + + } + + } else { + + // gl.TRIANGLE_STRIP + + for ( let i = 0; i < numberOfTriangles; i ++ ) { + + if ( i % 2 === 0 ) { + + newIndices.push( index.getX( i ) ); + newIndices.push( index.getX( i + 1 ) ); + newIndices.push( index.getX( i + 2 ) ); + + } else { + + newIndices.push( index.getX( i + 2 ) ); + newIndices.push( index.getX( i + 1 ) ); + newIndices.push( index.getX( i ) ); + + } + + } + + } + + if ( ( newIndices.length / 3 ) !== numberOfTriangles ) { + + console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' ); + + } + + // build final geometry + + const newGeometry = geometry.clone(); + newGeometry.setIndex( newIndices ); + newGeometry.clearGroups(); + + return newGeometry; + + } else { + + console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:', drawMode ); + return geometry; + + } + +} + +/** + * Calculates the morphed attributes of a morphed/skinned BufferGeometry. + * Helpful for Raytracing or Decals. + * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points. + * @return {Object} An Object with original position/normal attributes and morphed ones. + */ +function computeMorphedAttributes( object ) { + + const _vA = new Vector3(); + const _vB = new Vector3(); + const _vC = new Vector3(); + + const _tempA = new Vector3(); + const _tempB = new Vector3(); + const _tempC = new Vector3(); + + const _morphA = new Vector3(); + const _morphB = new Vector3(); + const _morphC = new Vector3(); + + function _calculateMorphedAttributeData( + object, + attribute, + morphAttribute, + morphTargetsRelative, + a, + b, + c, + modifiedAttributeArray + ) { + + _vA.fromBufferAttribute( attribute, a ); + _vB.fromBufferAttribute( attribute, b ); + _vC.fromBufferAttribute( attribute, c ); + + const morphInfluences = object.morphTargetInfluences; + + if ( morphAttribute && morphInfluences ) { + + _morphA.set( 0, 0, 0 ); + _morphB.set( 0, 0, 0 ); + _morphC.set( 0, 0, 0 ); + + for ( let i = 0, il = morphAttribute.length; i < il; i ++ ) { + + const influence = morphInfluences[ i ]; + const morph = morphAttribute[ i ]; + + if ( influence === 0 ) continue; + + _tempA.fromBufferAttribute( morph, a ); + _tempB.fromBufferAttribute( morph, b ); + _tempC.fromBufferAttribute( morph, c ); + + if ( morphTargetsRelative ) { + + _morphA.addScaledVector( _tempA, influence ); + _morphB.addScaledVector( _tempB, influence ); + _morphC.addScaledVector( _tempC, influence ); + + } else { + + _morphA.addScaledVector( _tempA.sub( _vA ), influence ); + _morphB.addScaledVector( _tempB.sub( _vB ), influence ); + _morphC.addScaledVector( _tempC.sub( _vC ), influence ); + + } + + } + + _vA.add( _morphA ); + _vB.add( _morphB ); + _vC.add( _morphC ); + + } + + if ( object.isSkinnedMesh ) { + + object.applyBoneTransform( a, _vA ); + object.applyBoneTransform( b, _vB ); + object.applyBoneTransform( c, _vC ); + + } + + modifiedAttributeArray[ a * 3 + 0 ] = _vA.x; + modifiedAttributeArray[ a * 3 + 1 ] = _vA.y; + modifiedAttributeArray[ a * 3 + 2 ] = _vA.z; + modifiedAttributeArray[ b * 3 + 0 ] = _vB.x; + modifiedAttributeArray[ b * 3 + 1 ] = _vB.y; + modifiedAttributeArray[ b * 3 + 2 ] = _vB.z; + modifiedAttributeArray[ c * 3 + 0 ] = _vC.x; + modifiedAttributeArray[ c * 3 + 1 ] = _vC.y; + modifiedAttributeArray[ c * 3 + 2 ] = _vC.z; + + } + + const geometry = object.geometry; + const material = object.material; + + let a, b, c; + const index = geometry.index; + const positionAttribute = geometry.attributes.position; + const morphPosition = geometry.morphAttributes.position; + const morphTargetsRelative = geometry.morphTargetsRelative; + const normalAttribute = geometry.attributes.normal; + const morphNormal = geometry.morphAttributes.position; + + const groups = geometry.groups; + const drawRange = geometry.drawRange; + let i, j, il, jl; + let group; + let start, end; + + const modifiedPosition = new Float32Array( positionAttribute.count * positionAttribute.itemSize ); + const modifiedNormal = new Float32Array( normalAttribute.count * normalAttribute.itemSize ); + + if ( index !== null ) { + + // indexed buffer geometry + + if ( Array.isArray( material ) ) { + + for ( i = 0, il = groups.length; i < il; i ++ ) { + + group = groups[ i ]; + + start = Math.max( group.start, drawRange.start ); + end = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ); + + for ( j = start, jl = end; j < jl; j += 3 ) { + + a = index.getX( j ); + b = index.getX( j + 1 ); + c = index.getX( j + 2 ); + + _calculateMorphedAttributeData( + object, + positionAttribute, + morphPosition, + morphTargetsRelative, + a, b, c, + modifiedPosition + ); + + _calculateMorphedAttributeData( + object, + normalAttribute, + morphNormal, + morphTargetsRelative, + a, b, c, + modifiedNormal + ); + + } + + } + + } else { + + start = Math.max( 0, drawRange.start ); + end = Math.min( index.count, ( drawRange.start + drawRange.count ) ); + + for ( i = start, il = end; i < il; i += 3 ) { + + a = index.getX( i ); + b = index.getX( i + 1 ); + c = index.getX( i + 2 ); + + _calculateMorphedAttributeData( + object, + positionAttribute, + morphPosition, + morphTargetsRelative, + a, b, c, + modifiedPosition + ); + + _calculateMorphedAttributeData( + object, + normalAttribute, + morphNormal, + morphTargetsRelative, + a, b, c, + modifiedNormal + ); + + } + + } + + } else { + + // non-indexed buffer geometry + + if ( Array.isArray( material ) ) { + + for ( i = 0, il = groups.length; i < il; i ++ ) { + + group = groups[ i ]; + + start = Math.max( group.start, drawRange.start ); + end = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ); + + for ( j = start, jl = end; j < jl; j += 3 ) { + + a = j; + b = j + 1; + c = j + 2; + + _calculateMorphedAttributeData( + object, + positionAttribute, + morphPosition, + morphTargetsRelative, + a, b, c, + modifiedPosition + ); + + _calculateMorphedAttributeData( + object, + normalAttribute, + morphNormal, + morphTargetsRelative, + a, b, c, + modifiedNormal + ); + + } + + } + + } else { + + start = Math.max( 0, drawRange.start ); + end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) ); + + for ( i = start, il = end; i < il; i += 3 ) { + + a = i; + b = i + 1; + c = i + 2; + + _calculateMorphedAttributeData( + object, + positionAttribute, + morphPosition, + morphTargetsRelative, + a, b, c, + modifiedPosition + ); + + _calculateMorphedAttributeData( + object, + normalAttribute, + morphNormal, + morphTargetsRelative, + a, b, c, + modifiedNormal + ); + + } + + } + + } + + const morphedPositionAttribute = new Float32BufferAttribute( modifiedPosition, 3 ); + const morphedNormalAttribute = new Float32BufferAttribute( modifiedNormal, 3 ); + + return { + + positionAttribute: positionAttribute, + normalAttribute: normalAttribute, + morphedPositionAttribute: morphedPositionAttribute, + morphedNormalAttribute: morphedNormalAttribute + + }; + +} + +function mergeGroups( geometry ) { + + if ( geometry.groups.length === 0 ) { + + console.warn( 'THREE.BufferGeometryUtils.mergeGroups(): No groups are defined. Nothing to merge.' ); + return geometry; + + } + + let groups = geometry.groups; + + // sort groups by material index + + groups = groups.sort( ( a, b ) => { + + if ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex; + + return a.start - b.start; + + } ); + + // create index for non-indexed geometries + + if ( geometry.getIndex() === null ) { + + const positionAttribute = geometry.getAttribute( 'position' ); + const indices = []; + + for ( let i = 0; i < positionAttribute.count; i += 3 ) { + + indices.push( i, i + 1, i + 2 ); + + } + + geometry.setIndex( indices ); + + } + + // sort index + + const index = geometry.getIndex(); + + const newIndices = []; + + for ( let i = 0; i < groups.length; i ++ ) { + + const group = groups[ i ]; + + const groupStart = group.start; + const groupLength = groupStart + group.count; + + for ( let j = groupStart; j < groupLength; j ++ ) { + + newIndices.push( index.getX( j ) ); + + } + + } + + geometry.dispose(); // Required to force buffer recreation + geometry.setIndex( newIndices ); + + // update groups indices + + let start = 0; + + for ( let i = 0; i < groups.length; i ++ ) { + + const group = groups[ i ]; + + group.start = start; + start += group.count; + + } + + // merge groups + + let currentGroup = groups[ 0 ]; + + geometry.groups = [ currentGroup ]; + + for ( let i = 1; i < groups.length; i ++ ) { + + const group = groups[ i ]; + + if ( currentGroup.materialIndex === group.materialIndex ) { + + currentGroup.count += group.count; + + } else { + + currentGroup = group; + geometry.groups.push( currentGroup ); + + } + + } + + return geometry; + +} + + +/** + * Modifies the supplied geometry if it is non-indexed, otherwise creates a new, + * non-indexed geometry. Returns the geometry with smooth normals everywhere except + * faces that meet at an angle greater than the crease angle. + * + * @param {BufferGeometry} geometry + * @param {number} [creaseAngle] + * @return {BufferGeometry} + */ +function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */ ) { + + const creaseDot = Math.cos( creaseAngle ); + const hashMultiplier = ( 1 + 1e-10 ) * 1e2; + + // reusable vectors + const verts = [ new Vector3(), new Vector3(), new Vector3() ]; + const tempVec1 = new Vector3(); + const tempVec2 = new Vector3(); + const tempNorm = new Vector3(); + const tempNorm2 = new Vector3(); + + // hashes a vector + function hashVertex( v ) { + + const x = ~ ~ ( v.x * hashMultiplier ); + const y = ~ ~ ( v.y * hashMultiplier ); + const z = ~ ~ ( v.z * hashMultiplier ); + return `${x},${y},${z}`; + + } + + // BufferGeometry.toNonIndexed() warns if the geometry is non-indexed + // and returns the original geometry + const resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry; + const posAttr = resultGeometry.attributes.position; + const vertexMap = {}; + + // find all the normals shared by commonly located vertices + for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) { + + const i3 = 3 * i; + const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 ); + const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 ); + const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 ); + + tempVec1.subVectors( c, b ); + tempVec2.subVectors( a, b ); + + // add the normal to the map for all vertices + const normal = new Vector3().crossVectors( tempVec1, tempVec2 ).normalize(); + for ( let n = 0; n < 3; n ++ ) { + + const vert = verts[ n ]; + const hash = hashVertex( vert ); + if ( ! ( hash in vertexMap ) ) { + + vertexMap[ hash ] = []; + + } + + vertexMap[ hash ].push( normal ); + + } + + } + + // average normals from all vertices that share a common location if they are within the + // provided crease threshold + const normalArray = new Float32Array( posAttr.count * 3 ); + const normAttr = new BufferAttribute( normalArray, 3, false ); + for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) { + + // get the face normal for this vertex + const i3 = 3 * i; + const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 ); + const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 ); + const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 ); + + tempVec1.subVectors( c, b ); + tempVec2.subVectors( a, b ); + + tempNorm.crossVectors( tempVec1, tempVec2 ).normalize(); + + // average all normals that meet the threshold and set the normal value + for ( let n = 0; n < 3; n ++ ) { + + const vert = verts[ n ]; + const hash = hashVertex( vert ); + const otherNormals = vertexMap[ hash ]; + tempNorm2.set( 0, 0, 0 ); + + for ( let k = 0, lk = otherNormals.length; k < lk; k ++ ) { + + const otherNorm = otherNormals[ k ]; + if ( tempNorm.dot( otherNorm ) > creaseDot ) { + + tempNorm2.add( otherNorm ); + + } + + } + + tempNorm2.normalize(); + normAttr.setXYZ( i3 + n, tempNorm2.x, tempNorm2.y, tempNorm2.z ); + + } + + } + + resultGeometry.setAttribute( 'normal', normAttr ); + return resultGeometry; + +} + +export { + computeMikkTSpaceTangents, + mergeGeometries, + mergeAttributes, + interleaveAttributes, + estimateBytesUsed, + mergeVertices, + toTrianglesDrawMode, + computeMorphedAttributes, + mergeGroups, + toCreasedNormals +}; diff --git a/seminar06-planning/simulator/js/objects/CarObject.js b/seminar06-planning/simulator/js/objects/CarObject.js new file mode 100644 index 0000000..c35f368 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/CarObject.js @@ -0,0 +1,122 @@ +import Car from "../physics/Car.js"; +import TDSLoader from "./TDSLoader.js"; +import suvModel from "../../models/suv.js"; + +const CAR_COLOR = 0x0088ff; +const WHEEL_COLOR = 0xff8800; + +export default class CarObject extends THREE.Object3D { + constructor(car) { + super(); + + this.car = car; + + this.buildCar2D(); + this.buildCar3D(); + } + + buildCar2D() { + const carMesh = new THREE.Mesh( + new THREE.PlaneGeometry(Car.HALF_CAR_LENGTH * 2, Car.HALF_CAR_WIDTH * 2), + new THREE.MeshBasicMaterial({ color: CAR_COLOR, depthTest: false, transparent: true, opacity: 0.7 }) + ); + carMesh.rotation.x = -Math.PI / 2; + carMesh.layers.set(2); + this.add(carMesh); + + const wheelGeometry = new THREE.PlaneGeometry(Car.HALF_WHEEL_LENGTH * 2, Car.HALF_WHEEL_WIDTH * 2); + const wheelMaterial = new THREE.MeshBasicMaterial({ color: WHEEL_COLOR, depthTest: false, transparent: true, opacity: 0.7 }) + + this.lfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial); + this.lfWheel2D.renderOrder = 1; + this.lfWheel2D.position.set(Car.FRONT_AXLE_POS, 0, Car.WHEEL_LATERAL_POS); + this.lfWheel2D.rotation.x = -Math.PI / 2; + this.lfWheel2D.layers.set(2); + this.add(this.lfWheel2D); + + this.rfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial); + this.rfWheel2D.renderOrder = 1; + this.rfWheel2D.position.set(Car.FRONT_AXLE_POS, 0, -Car.WHEEL_LATERAL_POS); + this.rfWheel2D.rotation.x = -Math.PI / 2; + this.rfWheel2D.layers.set(2); + this.add(this.rfWheel2D); + + const lrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial); + lrWheel.renderOrder = 1; + lrWheel.position.set(Car.REAR_AXLE_POS, 0, Car.WHEEL_LATERAL_POS); + lrWheel.rotation.x = -Math.PI / 2; + lrWheel.layers.set(2); + this.add(lrWheel); + + const rrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial); + rrWheel.renderOrder = 1; + rrWheel.position.set(Car.REAR_AXLE_POS, 0, -Car.WHEEL_LATERAL_POS); + rrWheel.rotation.x = -Math.PI / 2; + rrWheel.layers.set(2); + this.add(rrWheel); + } + + buildCar3D() { + const loader = new TDSLoader(); + loader.skipMaps = true; + + loader.load(suvModel, object => { + object.layers.set(3); + object.rotation.z = Math.PI / 2; + object.rotation.x = -Math.PI / 2; + + const box = (new THREE.Box3()).setFromObject(object); + const scaleLength = Car.HALF_CAR_LENGTH * 2 / (box.max.x - box.min.x); + const scaleWidth = Car.HALF_CAR_WIDTH * 2 / (box.max.z - box.min.z); + object.scale.set(scaleWidth, scaleLength, (scaleWidth + scaleLength) / 2); + + box.setFromObject(object); + object.position.setX(-(box.max.x + box.min.x) / 2); + object.position.setY(-box.min.y); + + this.add(object); + + const carMaterial = new THREE.MeshToonMaterial({ color: 0x0088ff }); + const wheelMaterial = new THREE.MeshToonMaterial({ color: 0xff8800 }); + + object.traverse(child => { + if (child instanceof THREE.Mesh) { + child.layers.set(3); + child.material = ['Toyota_RA7', 'Toyota_RA8', 'Toyota_RA9', 'Toyota_R10'].includes(child.name) ? wheelMaterial : carMaterial; + + if (child.name == 'Toyota_RA7') + this.lfWheel3D = child; + else if (child.name == 'Toyota_RA8') + this.rfWheel3D = child; + } + }); + + [this.lfWheel3D, this.rfWheel3D].forEach(wheel => { + wheel.geometry.computeBoundingBox(); + wheel.geometry.center(); + wheel.position.setY(wheel.position.y - 36); + wheel.position.setZ(wheel.position.z + 36); + }); + }); + } + + updateMatrix() { + this.updateCar(); + super.updateMatrix(); + } + + updateCar() { + const carPosition = this.car.position; + this.position.set(carPosition.x, 0, carPosition.y); + this.rotation.y = -this.car.rotation; + + const wheelAngle = this.car.wheelAngle; + + // Adding the wheels to the car object can trigger this function in some browsers + // before the other wheels are added, so check them first. + if (this.lfWheel2D) this.lfWheel2D.rotation.z = -wheelAngle; + if (this.rfWheel2D) this.rfWheel2D.rotation.z = -wheelAngle; + if (this.lfWheel3D) this.lfWheel3D.rotation.y = wheelAngle; + if (this.rfWheel3D) this.rfWheel3D.rotation.y = wheelAngle; + } +} diff --git a/seminar06-planning/simulator/js/objects/DynamicObstacleObject.js b/seminar06-planning/simulator/js/objects/DynamicObstacleObject.js new file mode 100644 index 0000000..b71d0b1 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/DynamicObstacleObject.js @@ -0,0 +1,59 @@ +export default class DynamicObstacleObject extends THREE.Object3D { + constructor(dynamicObstacle, lanePath) { + super(); + + this.dynamicObstacle = dynamicObstacle; + this.lanePath = lanePath; + this.size = dynamicObstacle.size; + + const colors = { + vehicle: 0xff8800, + cyclist: 0x00ccff, + pedestrian: 0xffdd00 + }; + + const heights = { + vehicle: 2.0, + cyclist: 1.8, + pedestrian: 1.8 + }; + + const mesh2D = new THREE.Mesh( + new THREE.PlaneGeometry(dynamicObstacle.size.w * 2, dynamicObstacle.size.h * 2), + new THREE.MeshBasicMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, depthTest: false, transparent: true, opacity: 0.7 }) + ); + mesh2D.rotation.x = -Math.PI / 2; + mesh2D.layers.set(2); + this.add(mesh2D); + + const mesh3D = new THREE.Mesh( + new THREE.BoxBufferGeometry(dynamicObstacle.size.w * 2, heights[dynamicObstacle.type] || 1.5, dynamicObstacle.size.h * 2), + new THREE.MeshToonMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, transparent: true, opacity: 0.7 }) + ); + mesh3D.position.setY((heights[dynamicObstacle.type] || 1.5) / 2); + mesh3D.layers.set(3); + this.add(mesh3D); + } + + update(time) { + const slPos = this.dynamicObstacle.positionAtTime(time); + + // Sample just the station this dynamic obstacle is at + const [sample] = this.lanePath.sampleStations(slPos.x, 1, 0); + + if (sample === undefined) { + this.visible = false; + return; + } + + const rot = sample.rot; + const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(slPos.y).add(sample.pos); + + this.position.set(pos.x, 0, pos.y); + this.rotation.y = -rot; + + super.updateMatrix(); + + this.visible = slPos.x >= 0; + } +} diff --git a/seminar06-planning/simulator/js/objects/GLTFLoader.js b/seminar06-planning/simulator/js/objects/GLTFLoader.js new file mode 100644 index 0000000..fcc4832 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/GLTFLoader.js @@ -0,0 +1,4669 @@ +import { + AnimationClip, + Bone, + Box3, + BufferAttribute, + BufferGeometry, + ClampToEdgeWrapping, + Color, + ColorManagement, + DirectionalLight, + DoubleSide, + FileLoader, + FrontSide, + Group, + ImageBitmapLoader, + InstancedMesh, + InterleavedBuffer, + InterleavedBufferAttribute, + Interpolant, + InterpolateDiscrete, + InterpolateLinear, + Line, + LineBasicMaterial, + LineLoop, + LineSegments, + LinearFilter, + LinearMipmapLinearFilter, + LinearMipmapNearestFilter, + LinearSRGBColorSpace, + Loader, + LoaderUtils, + Material, + MathUtils, + Matrix4, + Mesh, + MeshBasicMaterial, + MeshPhysicalMaterial, + MeshStandardMaterial, + MirroredRepeatWrapping, + NearestFilter, + NearestMipmapLinearFilter, + NearestMipmapNearestFilter, + NumberKeyframeTrack, + Object3D, + OrthographicCamera, + PerspectiveCamera, + PointLight, + Points, + PointsMaterial, + PropertyBinding, + Quaternion, + QuaternionKeyframeTrack, + RepeatWrapping, + Skeleton, + SkinnedMesh, + Sphere, + SpotLight, + Texture, + TextureLoader, + TriangleFanDrawMode, + TriangleStripDrawMode, + Vector2, + Vector3, + VectorKeyframeTrack, + SRGBColorSpace, + InstancedBufferAttribute +} from 'three'; +import { toTrianglesDrawMode } from './BufferGeometryUtils.js'; + +class GLTFLoader extends Loader { + + constructor( manager ) { + + super( manager ); + + this.dracoLoader = null; + this.ktx2Loader = null; + this.meshoptDecoder = null; + + this.pluginCallbacks = []; + + this.register( function ( parser ) { + + return new GLTFMaterialsClearcoatExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFTextureBasisUExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFTextureWebPExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFTextureAVIFExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsSheenExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsTransmissionExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsVolumeExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsIorExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsEmissiveStrengthExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsSpecularExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsIridescenceExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsAnisotropyExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMaterialsBumpExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFLightsExtension( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMeshoptCompression( parser ); + + } ); + + this.register( function ( parser ) { + + return new GLTFMeshGpuInstancing( parser ); + + } ); + + } + + load( url, onLoad, onProgress, onError ) { + + const scope = this; + + let resourcePath; + + if ( this.resourcePath !== '' ) { + + resourcePath = this.resourcePath; + + } else if ( this.path !== '' ) { + + // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file + // Example path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf' + // resourcePath = 'https://my-cnd-server.com/assets/models/' + // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin' + // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png' + const relativeUrl = LoaderUtils.extractUrlBase( url ); + resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path ); + + } else { + + resourcePath = LoaderUtils.extractUrlBase( url ); + + } + + // Tells the LoadingManager to track an extra item, which resolves after + // the model is fully loaded. This means the count of items loaded will + // be incorrect, but ensures manager.onLoad() does not fire early. + this.manager.itemStart( url ); + + const _onError = function ( e ) { + + if ( onError ) { + + onError( e ); + + } else { + + console.error( e ); + + } + + scope.manager.itemError( url ); + scope.manager.itemEnd( url ); + + }; + + const loader = new FileLoader( this.manager ); + + loader.setPath( this.path ); + loader.setResponseType( 'arraybuffer' ); + loader.setRequestHeader( this.requestHeader ); + loader.setWithCredentials( this.withCredentials ); + + loader.load( url, function ( data ) { + + try { + + scope.parse( data, resourcePath, function ( gltf ) { + + onLoad( gltf ); + + scope.manager.itemEnd( url ); + + }, _onError ); + + } catch ( e ) { + + _onError( e ); + + } + + }, onProgress, _onError ); + + } + + setDRACOLoader( dracoLoader ) { + + this.dracoLoader = dracoLoader; + return this; + + } + + setDDSLoader() { + + throw new Error( + + 'THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".' + + ); + + } + + setKTX2Loader( ktx2Loader ) { + + this.ktx2Loader = ktx2Loader; + return this; + + } + + setMeshoptDecoder( meshoptDecoder ) { + + this.meshoptDecoder = meshoptDecoder; + return this; + + } + + register( callback ) { + + if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) { + + this.pluginCallbacks.push( callback ); + + } + + return this; + + } + + unregister( callback ) { + + if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) { + + this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 ); + + } + + return this; + + } + + parse( data, path, onLoad, onError ) { + + let json; + const extensions = {}; + const plugins = {}; + const textDecoder = new TextDecoder(); + + if ( typeof data === 'string' ) { + + json = JSON.parse( data ); + + } else if ( data instanceof ArrayBuffer ) { + + const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) ); + + if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) { + + try { + + extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data ); + + } catch ( error ) { + + if ( onError ) onError( error ); + return; + + } + + json = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content ); + + } else { + + json = JSON.parse( textDecoder.decode( data ) ); + + } + + } else { + + json = data; + + } + + if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) { + + if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) ); + return; + + } + + const parser = new GLTFParser( json, { + + path: path || this.resourcePath || '', + crossOrigin: this.crossOrigin, + requestHeader: this.requestHeader, + manager: this.manager, + ktx2Loader: this.ktx2Loader, + meshoptDecoder: this.meshoptDecoder + + } ); + + parser.fileLoader.setRequestHeader( this.requestHeader ); + + for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) { + + const plugin = this.pluginCallbacks[ i ]( parser ); + + if ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' ); + + plugins[ plugin.name ] = plugin; + + // Workaround to avoid determining as unknown extension + // in addUnknownExtensionsToUserData(). + // Remove this workaround if we move all the existing + // extension handlers to plugin system + extensions[ plugin.name ] = true; + + } + + if ( json.extensionsUsed ) { + + for ( let i = 0; i < json.extensionsUsed.length; ++ i ) { + + const extensionName = json.extensionsUsed[ i ]; + const extensionsRequired = json.extensionsRequired || []; + + switch ( extensionName ) { + + case EXTENSIONS.KHR_MATERIALS_UNLIT: + extensions[ extensionName ] = new GLTFMaterialsUnlitExtension(); + break; + + case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION: + extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader ); + break; + + case EXTENSIONS.KHR_TEXTURE_TRANSFORM: + extensions[ extensionName ] = new GLTFTextureTransformExtension(); + break; + + case EXTENSIONS.KHR_MESH_QUANTIZATION: + extensions[ extensionName ] = new GLTFMeshQuantizationExtension(); + break; + + default: + + if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) { + + console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' ); + + } + + } + + } + + } + + parser.setExtensions( extensions ); + parser.setPlugins( plugins ); + parser.parse( onLoad, onError ); + + } + + parseAsync( data, path ) { + + const scope = this; + + return new Promise( function ( resolve, reject ) { + + scope.parse( data, path, resolve, reject ); + + } ); + + } + +} + +/* GLTFREGISTRY */ + +function GLTFRegistry() { + + let objects = {}; + + return { + + get: function ( key ) { + + return objects[ key ]; + + }, + + add: function ( key, object ) { + + objects[ key ] = object; + + }, + + remove: function ( key ) { + + delete objects[ key ]; + + }, + + removeAll: function () { + + objects = {}; + + } + + }; + +} + +/*********************************/ +/********** EXTENSIONS ***********/ +/*********************************/ + +const EXTENSIONS = { + KHR_BINARY_GLTF: 'KHR_binary_glTF', + KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression', + KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual', + KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat', + KHR_MATERIALS_IOR: 'KHR_materials_ior', + KHR_MATERIALS_SHEEN: 'KHR_materials_sheen', + KHR_MATERIALS_SPECULAR: 'KHR_materials_specular', + KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission', + KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence', + KHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy', + KHR_MATERIALS_UNLIT: 'KHR_materials_unlit', + KHR_MATERIALS_VOLUME: 'KHR_materials_volume', + KHR_TEXTURE_BASISU: 'KHR_texture_basisu', + KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform', + KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization', + KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength', + EXT_MATERIALS_BUMP: 'EXT_materials_bump', + EXT_TEXTURE_WEBP: 'EXT_texture_webp', + EXT_TEXTURE_AVIF: 'EXT_texture_avif', + EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression', + EXT_MESH_GPU_INSTANCING: 'EXT_mesh_gpu_instancing' +}; + +/** + * Punctual Lights Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual + */ +class GLTFLightsExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL; + + // Object3D instance caches + this.cache = { refs: {}, uses: {} }; + + } + + _markDefs() { + + const parser = this.parser; + const nodeDefs = this.parser.json.nodes || []; + + for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) { + + const nodeDef = nodeDefs[ nodeIndex ]; + + if ( nodeDef.extensions + && nodeDef.extensions[ this.name ] + && nodeDef.extensions[ this.name ].light !== undefined ) { + + parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light ); + + } + + } + + } + + _loadLight( lightIndex ) { + + const parser = this.parser; + const cacheKey = 'light:' + lightIndex; + let dependency = parser.cache.get( cacheKey ); + + if ( dependency ) return dependency; + + const json = parser.json; + const extensions = ( json.extensions && json.extensions[ this.name ] ) || {}; + const lightDefs = extensions.lights || []; + const lightDef = lightDefs[ lightIndex ]; + let lightNode; + + const color = new Color( 0xffffff ); + + if ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace ); + + const range = lightDef.range !== undefined ? lightDef.range : 0; + + switch ( lightDef.type ) { + + case 'directional': + lightNode = new DirectionalLight( color ); + lightNode.target.position.set( 0, 0, - 1 ); + lightNode.add( lightNode.target ); + break; + + case 'point': + lightNode = new PointLight( color ); + lightNode.distance = range; + break; + + case 'spot': + lightNode = new SpotLight( color ); + lightNode.distance = range; + // Handle spotlight properties. + lightDef.spot = lightDef.spot || {}; + lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0; + lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0; + lightNode.angle = lightDef.spot.outerConeAngle; + lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle; + lightNode.target.position.set( 0, 0, - 1 ); + lightNode.add( lightNode.target ); + break; + + default: + throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type ); + + } + + // Some lights (e.g. spot) default to a position other than the origin. Reset the position + // here, because node-level parsing will only override position if explicitly specified. + lightNode.position.set( 0, 0, 0 ); + + lightNode.decay = 2; + + assignExtrasToUserData( lightNode, lightDef ); + + if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity; + + lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) ); + + dependency = Promise.resolve( lightNode ); + + parser.cache.add( cacheKey, dependency ); + + return dependency; + + } + + getDependency( type, index ) { + + if ( type !== 'light' ) return; + + return this._loadLight( index ); + + } + + createNodeAttachment( nodeIndex ) { + + const self = this; + const parser = this.parser; + const json = parser.json; + const nodeDef = json.nodes[ nodeIndex ]; + const lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {}; + const lightIndex = lightDef.light; + + if ( lightIndex === undefined ) return null; + + return this._loadLight( lightIndex ).then( function ( light ) { + + return parser._getNodeRef( self.cache, lightIndex, light ); + + } ); + + } + +} + +/** + * Unlit Materials Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit + */ +class GLTFMaterialsUnlitExtension { + + constructor() { + + this.name = EXTENSIONS.KHR_MATERIALS_UNLIT; + + } + + getMaterialType() { + + return MeshBasicMaterial; + + } + + extendParams( materialParams, materialDef, parser ) { + + const pending = []; + + materialParams.color = new Color( 1.0, 1.0, 1.0 ); + materialParams.opacity = 1.0; + + const metallicRoughness = materialDef.pbrMetallicRoughness; + + if ( metallicRoughness ) { + + if ( Array.isArray( metallicRoughness.baseColorFactor ) ) { + + const array = metallicRoughness.baseColorFactor; + + materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace ); + materialParams.opacity = array[ 3 ]; + + } + + if ( metallicRoughness.baseColorTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) ); + + } + + } + + return Promise.all( pending ); + + } + +} + +/** + * Materials Emissive Strength Extension + * + * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md + */ +class GLTFMaterialsEmissiveStrengthExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength; + + if ( emissiveStrength !== undefined ) { + + materialParams.emissiveIntensity = emissiveStrength; + + } + + return Promise.resolve(); + + } + +} + +/** + * Clearcoat Materials Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat + */ +class GLTFMaterialsClearcoatExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + if ( extension.clearcoatFactor !== undefined ) { + + materialParams.clearcoat = extension.clearcoatFactor; + + } + + if ( extension.clearcoatTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) ); + + } + + if ( extension.clearcoatRoughnessFactor !== undefined ) { + + materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor; + + } + + if ( extension.clearcoatRoughnessTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) ); + + } + + if ( extension.clearcoatNormalTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) ); + + if ( extension.clearcoatNormalTexture.scale !== undefined ) { + + const scale = extension.clearcoatNormalTexture.scale; + + materialParams.clearcoatNormalScale = new Vector2( scale, scale ); + + } + + } + + return Promise.all( pending ); + + } + +} + +/** + * Iridescence Materials Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence + */ +class GLTFMaterialsIridescenceExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + if ( extension.iridescenceFactor !== undefined ) { + + materialParams.iridescence = extension.iridescenceFactor; + + } + + if ( extension.iridescenceTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) ); + + } + + if ( extension.iridescenceIor !== undefined ) { + + materialParams.iridescenceIOR = extension.iridescenceIor; + + } + + if ( materialParams.iridescenceThicknessRange === undefined ) { + + materialParams.iridescenceThicknessRange = [ 100, 400 ]; + + } + + if ( extension.iridescenceThicknessMinimum !== undefined ) { + + materialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum; + + } + + if ( extension.iridescenceThicknessMaximum !== undefined ) { + + materialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum; + + } + + if ( extension.iridescenceThicknessTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) ); + + } + + return Promise.all( pending ); + + } + +} + +/** + * Sheen Materials Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen + */ +class GLTFMaterialsSheenExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_SHEEN; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + materialParams.sheenColor = new Color( 0, 0, 0 ); + materialParams.sheenRoughness = 0; + materialParams.sheen = 1; + + const extension = materialDef.extensions[ this.name ]; + + if ( extension.sheenColorFactor !== undefined ) { + + const colorFactor = extension.sheenColorFactor; + materialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace ); + + } + + if ( extension.sheenRoughnessFactor !== undefined ) { + + materialParams.sheenRoughness = extension.sheenRoughnessFactor; + + } + + if ( extension.sheenColorTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) ); + + } + + if ( extension.sheenRoughnessTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) ); + + } + + return Promise.all( pending ); + + } + +} + +/** + * Transmission Materials Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission + * Draft: https://github.com/KhronosGroup/glTF/pull/1698 + */ +class GLTFMaterialsTransmissionExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + if ( extension.transmissionFactor !== undefined ) { + + materialParams.transmission = extension.transmissionFactor; + + } + + if ( extension.transmissionTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) ); + + } + + return Promise.all( pending ); + + } + +} + +/** + * Materials Volume Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume + */ +class GLTFMaterialsVolumeExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_VOLUME; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0; + + if ( extension.thicknessTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) ); + + } + + materialParams.attenuationDistance = extension.attenuationDistance || Infinity; + + const colorArray = extension.attenuationColor || [ 1, 1, 1 ]; + materialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace ); + + return Promise.all( pending ); + + } + +} + +/** + * Materials ior Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior + */ +class GLTFMaterialsIorExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_IOR; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const extension = materialDef.extensions[ this.name ]; + + materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5; + + return Promise.resolve(); + + } + +} + +/** + * Materials specular Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular + */ +class GLTFMaterialsSpecularExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0; + + if ( extension.specularTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) ); + + } + + const colorArray = extension.specularColorFactor || [ 1, 1, 1 ]; + materialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace ); + + if ( extension.specularColorTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) ); + + } + + return Promise.all( pending ); + + } + +} + + +/** + * Materials bump Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump + */ +class GLTFMaterialsBumpExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.EXT_MATERIALS_BUMP; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0; + + if ( extension.bumpTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) ); + + } + + return Promise.all( pending ); + + } + +} + +/** + * Materials anisotropy Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy + */ +class GLTFMaterialsAnisotropyExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY; + + } + + getMaterialType( materialIndex ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null; + + return MeshPhysicalMaterial; + + } + + extendMaterialParams( materialIndex, materialParams ) { + + const parser = this.parser; + const materialDef = parser.json.materials[ materialIndex ]; + + if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) { + + return Promise.resolve(); + + } + + const pending = []; + + const extension = materialDef.extensions[ this.name ]; + + if ( extension.anisotropyStrength !== undefined ) { + + materialParams.anisotropy = extension.anisotropyStrength; + + } + + if ( extension.anisotropyRotation !== undefined ) { + + materialParams.anisotropyRotation = extension.anisotropyRotation; + + } + + if ( extension.anisotropyTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'anisotropyMap', extension.anisotropyTexture ) ); + + } + + return Promise.all( pending ); + + } + +} + +/** + * BasisU Texture Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu + */ +class GLTFTextureBasisUExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.KHR_TEXTURE_BASISU; + + } + + loadTexture( textureIndex ) { + + const parser = this.parser; + const json = parser.json; + + const textureDef = json.textures[ textureIndex ]; + + if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) { + + return null; + + } + + const extension = textureDef.extensions[ this.name ]; + const loader = parser.options.ktx2Loader; + + if ( ! loader ) { + + if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) { + + throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' ); + + } else { + + // Assumes that the extension is optional and that a fallback texture is present + return null; + + } + + } + + return parser.loadTextureImage( textureIndex, extension.source, loader ); + + } + +} + +/** + * WebP Texture Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp + */ +class GLTFTextureWebPExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.EXT_TEXTURE_WEBP; + this.isSupported = null; + + } + + loadTexture( textureIndex ) { + + const name = this.name; + const parser = this.parser; + const json = parser.json; + + const textureDef = json.textures[ textureIndex ]; + + if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) { + + return null; + + } + + const extension = textureDef.extensions[ name ]; + const source = json.images[ extension.source ]; + + let loader = parser.textureLoader; + if ( source.uri ) { + + const handler = parser.options.manager.getHandler( source.uri ); + if ( handler !== null ) loader = handler; + + } + + return this.detectSupport().then( function ( isSupported ) { + + if ( isSupported ) return parser.loadTextureImage( textureIndex, extension.source, loader ); + + if ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) { + + throw new Error( 'THREE.GLTFLoader: WebP required by asset but unsupported.' ); + + } + + // Fall back to PNG or JPEG. + return parser.loadTexture( textureIndex ); + + } ); + + } + + detectSupport() { + + if ( ! this.isSupported ) { + + this.isSupported = new Promise( function ( resolve ) { + + const image = new Image(); + + // Lossy test image. Support for lossy images doesn't guarantee support for all + // WebP images, unfortunately. + image.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA'; + + image.onload = image.onerror = function () { + + resolve( image.height === 1 ); + + }; + + } ); + + } + + return this.isSupported; + + } + +} + +/** + * AVIF Texture Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif + */ +class GLTFTextureAVIFExtension { + + constructor( parser ) { + + this.parser = parser; + this.name = EXTENSIONS.EXT_TEXTURE_AVIF; + this.isSupported = null; + + } + + loadTexture( textureIndex ) { + + const name = this.name; + const parser = this.parser; + const json = parser.json; + + const textureDef = json.textures[ textureIndex ]; + + if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) { + + return null; + + } + + const extension = textureDef.extensions[ name ]; + const source = json.images[ extension.source ]; + + let loader = parser.textureLoader; + if ( source.uri ) { + + const handler = parser.options.manager.getHandler( source.uri ); + if ( handler !== null ) loader = handler; + + } + + return this.detectSupport().then( function ( isSupported ) { + + if ( isSupported ) return parser.loadTextureImage( textureIndex, extension.source, loader ); + + if ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) { + + throw new Error( 'THREE.GLTFLoader: AVIF required by asset but unsupported.' ); + + } + + // Fall back to PNG or JPEG. + return parser.loadTexture( textureIndex ); + + } ); + + } + + detectSupport() { + + if ( ! this.isSupported ) { + + this.isSupported = new Promise( function ( resolve ) { + + const image = new Image(); + + // Lossy test image. + image.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI='; + image.onload = image.onerror = function () { + + resolve( image.height === 1 ); + + }; + + } ); + + } + + return this.isSupported; + + } + +} + +/** + * meshopt BufferView Compression Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression + */ +class GLTFMeshoptCompression { + + constructor( parser ) { + + this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION; + this.parser = parser; + + } + + loadBufferView( index ) { + + const json = this.parser.json; + const bufferView = json.bufferViews[ index ]; + + if ( bufferView.extensions && bufferView.extensions[ this.name ] ) { + + const extensionDef = bufferView.extensions[ this.name ]; + + const buffer = this.parser.getDependency( 'buffer', extensionDef.buffer ); + const decoder = this.parser.options.meshoptDecoder; + + if ( ! decoder || ! decoder.supported ) { + + if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) { + + throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' ); + + } else { + + // Assumes that the extension is optional and that fallback buffer data is present + return null; + + } + + } + + return buffer.then( function ( res ) { + + const byteOffset = extensionDef.byteOffset || 0; + const byteLength = extensionDef.byteLength || 0; + + const count = extensionDef.count; + const stride = extensionDef.byteStride; + + const source = new Uint8Array( res, byteOffset, byteLength ); + + if ( decoder.decodeGltfBufferAsync ) { + + return decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) { + + return res.buffer; + + } ); + + } else { + + // Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync + return decoder.ready.then( function () { + + const result = new ArrayBuffer( count * stride ); + decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter ); + return result; + + } ); + + } + + } ); + + } else { + + return null; + + } + + } + +} + +/** + * GPU Instancing Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing + * + */ +class GLTFMeshGpuInstancing { + + constructor( parser ) { + + this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING; + this.parser = parser; + + } + + createNodeMesh( nodeIndex ) { + + const json = this.parser.json; + const nodeDef = json.nodes[ nodeIndex ]; + + if ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] || + nodeDef.mesh === undefined ) { + + return null; + + } + + const meshDef = json.meshes[ nodeDef.mesh ]; + + // No Points or Lines + Instancing support yet + + for ( const primitive of meshDef.primitives ) { + + if ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES && + primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP && + primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN && + primitive.mode !== undefined ) { + + return null; + + } + + } + + const extensionDef = nodeDef.extensions[ this.name ]; + const attributesDef = extensionDef.attributes; + + // @TODO: Can we support InstancedMesh + SkinnedMesh? + + const pending = []; + const attributes = {}; + + for ( const key in attributesDef ) { + + pending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => { + + attributes[ key ] = accessor; + return attributes[ key ]; + + } ) ); + + } + + if ( pending.length < 1 ) { + + return null; + + } + + pending.push( this.parser.createNodeMesh( nodeIndex ) ); + + return Promise.all( pending ).then( results => { + + const nodeObject = results.pop(); + const meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ]; + const count = results[ 0 ].count; // All attribute counts should be same + const instancedMeshes = []; + + for ( const mesh of meshes ) { + + // Temporal variables + const m = new Matrix4(); + const p = new Vector3(); + const q = new Quaternion(); + const s = new Vector3( 1, 1, 1 ); + + const instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count ); + + for ( let i = 0; i < count; i ++ ) { + + if ( attributes.TRANSLATION ) { + + p.fromBufferAttribute( attributes.TRANSLATION, i ); + + } + + if ( attributes.ROTATION ) { + + q.fromBufferAttribute( attributes.ROTATION, i ); + + } + + if ( attributes.SCALE ) { + + s.fromBufferAttribute( attributes.SCALE, i ); + + } + + instancedMesh.setMatrixAt( i, m.compose( p, q, s ) ); + + } + + // Add instance attributes to the geometry, excluding TRS. + for ( const attributeName in attributes ) { + + if ( attributeName === '_COLOR_0' ) { + + const attr = attributes[ attributeName ]; + instancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized ); + + } else if ( attributeName !== 'TRANSLATION' && + attributeName !== 'ROTATION' && + attributeName !== 'SCALE' ) { + + mesh.geometry.setAttribute( attributeName, attributes[ attributeName ] ); + + } + + } + + // Just in case + Object3D.prototype.copy.call( instancedMesh, mesh ); + + this.parser.assignFinalMaterial( instancedMesh ); + + instancedMeshes.push( instancedMesh ); + + } + + if ( nodeObject.isGroup ) { + + nodeObject.clear(); + + nodeObject.add( ... instancedMeshes ); + + return nodeObject; + + } + + return instancedMeshes[ 0 ]; + + } ); + + } + +} + +/* BINARY EXTENSION */ +const BINARY_EXTENSION_HEADER_MAGIC = 'glTF'; +const BINARY_EXTENSION_HEADER_LENGTH = 12; +const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 }; + +class GLTFBinaryExtension { + + constructor( data ) { + + this.name = EXTENSIONS.KHR_BINARY_GLTF; + this.content = null; + this.body = null; + + const headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH ); + const textDecoder = new TextDecoder(); + + this.header = { + magic: textDecoder.decode( new Uint8Array( data.slice( 0, 4 ) ) ), + version: headerView.getUint32( 4, true ), + length: headerView.getUint32( 8, true ) + }; + + if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) { + + throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' ); + + } else if ( this.header.version < 2.0 ) { + + throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' ); + + } + + const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH; + const chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH ); + let chunkIndex = 0; + + while ( chunkIndex < chunkContentsLength ) { + + const chunkLength = chunkView.getUint32( chunkIndex, true ); + chunkIndex += 4; + + const chunkType = chunkView.getUint32( chunkIndex, true ); + chunkIndex += 4; + + if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) { + + const contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength ); + this.content = textDecoder.decode( contentArray ); + + } else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) { + + const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex; + this.body = data.slice( byteOffset, byteOffset + chunkLength ); + + } + + // Clients must ignore chunks with unknown types. + + chunkIndex += chunkLength; + + } + + if ( this.content === null ) { + + throw new Error( 'THREE.GLTFLoader: JSON content not found.' ); + + } + + } + +} + +/** + * DRACO Mesh Compression Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression + */ +class GLTFDracoMeshCompressionExtension { + + constructor( json, dracoLoader ) { + + if ( ! dracoLoader ) { + + throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' ); + + } + + this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION; + this.json = json; + this.dracoLoader = dracoLoader; + this.dracoLoader.preload(); + + } + + decodePrimitive( primitive, parser ) { + + const json = this.json; + const dracoLoader = this.dracoLoader; + const bufferViewIndex = primitive.extensions[ this.name ].bufferView; + const gltfAttributeMap = primitive.extensions[ this.name ].attributes; + const threeAttributeMap = {}; + const attributeNormalizedMap = {}; + const attributeTypeMap = {}; + + for ( const attributeName in gltfAttributeMap ) { + + const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase(); + + threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ]; + + } + + for ( const attributeName in primitive.attributes ) { + + const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase(); + + if ( gltfAttributeMap[ attributeName ] !== undefined ) { + + const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ]; + const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]; + + attributeTypeMap[ threeAttributeName ] = componentType.name; + attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true; + + } + + } + + return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) { + + return new Promise( function ( resolve, reject ) { + + dracoLoader.decodeDracoFile( bufferView, function ( geometry ) { + + for ( const attributeName in geometry.attributes ) { + + const attribute = geometry.attributes[ attributeName ]; + const normalized = attributeNormalizedMap[ attributeName ]; + + if ( normalized !== undefined ) attribute.normalized = normalized; + + } + + resolve( geometry ); + + }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject ); + + } ); + + } ); + + } + +} + +/** + * Texture Transform Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform + */ +class GLTFTextureTransformExtension { + + constructor() { + + this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM; + + } + + extendTexture( texture, transform ) { + + if ( ( transform.texCoord === undefined || transform.texCoord === texture.channel ) + && transform.offset === undefined + && transform.rotation === undefined + && transform.scale === undefined ) { + + // See https://github.com/mrdoob/three.js/issues/21819. + return texture; + + } + + texture = texture.clone(); + + if ( transform.texCoord !== undefined ) { + + texture.channel = transform.texCoord; + + } + + if ( transform.offset !== undefined ) { + + texture.offset.fromArray( transform.offset ); + + } + + if ( transform.rotation !== undefined ) { + + texture.rotation = transform.rotation; + + } + + if ( transform.scale !== undefined ) { + + texture.repeat.fromArray( transform.scale ); + + } + + texture.needsUpdate = true; + + return texture; + + } + +} + +/** + * Mesh Quantization Extension + * + * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization + */ +class GLTFMeshQuantizationExtension { + + constructor() { + + this.name = EXTENSIONS.KHR_MESH_QUANTIZATION; + + } + +} + +/*********************************/ +/********** INTERPOLATION ********/ +/*********************************/ + +// Spline Interpolation +// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation +class GLTFCubicSplineInterpolant extends Interpolant { + + constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + super( parameterPositions, sampleValues, sampleSize, resultBuffer ); + + } + + copySampleValue_( index ) { + + // Copies a sample value to the result buffer. See description of glTF + // CUBICSPLINE values layout in interpolate_() function below. + + const result = this.resultBuffer, + values = this.sampleValues, + valueSize = this.valueSize, + offset = index * valueSize * 3 + valueSize; + + for ( let i = 0; i !== valueSize; i ++ ) { + + result[ i ] = values[ offset + i ]; + + } + + return result; + + } + + interpolate_( i1, t0, t, t1 ) { + + const result = this.resultBuffer; + const values = this.sampleValues; + const stride = this.valueSize; + + const stride2 = stride * 2; + const stride3 = stride * 3; + + const td = t1 - t0; + + const p = ( t - t0 ) / td; + const pp = p * p; + const ppp = pp * p; + + const offset1 = i1 * stride3; + const offset0 = offset1 - stride3; + + const s2 = - 2 * ppp + 3 * pp; + const s3 = ppp - pp; + const s0 = 1 - s2; + const s1 = s3 - pp + p; + + // Layout of keyframe output values for CUBICSPLINE animations: + // [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ] + for ( let i = 0; i !== stride; i ++ ) { + + const p0 = values[ offset0 + i + stride ]; // splineVertex_k + const m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k) + const p1 = values[ offset1 + i + stride ]; // splineVertex_k+1 + const m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k) + + result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1; + + } + + return result; + + } + +} + +const _q = new Quaternion(); + +class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant { + + interpolate_( i1, t0, t, t1 ) { + + const result = super.interpolate_( i1, t0, t, t1 ); + + _q.fromArray( result ).normalize().toArray( result ); + + return result; + + } + +} + + +/*********************************/ +/********** INTERNALS ************/ +/*********************************/ + +/* CONSTANTS */ + +const WEBGL_CONSTANTS = { + FLOAT: 5126, + //FLOAT_MAT2: 35674, + FLOAT_MAT3: 35675, + FLOAT_MAT4: 35676, + FLOAT_VEC2: 35664, + FLOAT_VEC3: 35665, + FLOAT_VEC4: 35666, + LINEAR: 9729, + REPEAT: 10497, + SAMPLER_2D: 35678, + POINTS: 0, + LINES: 1, + LINE_LOOP: 2, + LINE_STRIP: 3, + TRIANGLES: 4, + TRIANGLE_STRIP: 5, + TRIANGLE_FAN: 6, + UNSIGNED_BYTE: 5121, + UNSIGNED_SHORT: 5123 +}; + +const WEBGL_COMPONENT_TYPES = { + 5120: Int8Array, + 5121: Uint8Array, + 5122: Int16Array, + 5123: Uint16Array, + 5125: Uint32Array, + 5126: Float32Array +}; + +const WEBGL_FILTERS = { + 9728: NearestFilter, + 9729: LinearFilter, + 9984: NearestMipmapNearestFilter, + 9985: LinearMipmapNearestFilter, + 9986: NearestMipmapLinearFilter, + 9987: LinearMipmapLinearFilter +}; + +const WEBGL_WRAPPINGS = { + 33071: ClampToEdgeWrapping, + 33648: MirroredRepeatWrapping, + 10497: RepeatWrapping +}; + +const WEBGL_TYPE_SIZES = { + 'SCALAR': 1, + 'VEC2': 2, + 'VEC3': 3, + 'VEC4': 4, + 'MAT2': 4, + 'MAT3': 9, + 'MAT4': 16 +}; + +const ATTRIBUTES = { + POSITION: 'position', + NORMAL: 'normal', + TANGENT: 'tangent', + TEXCOORD_0: 'uv', + TEXCOORD_1: 'uv1', + TEXCOORD_2: 'uv2', + TEXCOORD_3: 'uv3', + COLOR_0: 'color', + WEIGHTS_0: 'skinWeight', + JOINTS_0: 'skinIndex', +}; + +const PATH_PROPERTIES = { + scale: 'scale', + translation: 'position', + rotation: 'quaternion', + weights: 'morphTargetInfluences' +}; + +const INTERPOLATION = { + CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each + // keyframe track will be initialized with a default interpolation type, then modified. + LINEAR: InterpolateLinear, + STEP: InterpolateDiscrete +}; + +const ALPHA_MODES = { + OPAQUE: 'OPAQUE', + MASK: 'MASK', + BLEND: 'BLEND' +}; + +/** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material + */ +function createDefaultMaterial( cache ) { + + if ( cache[ 'DefaultMaterial' ] === undefined ) { + + cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( { + color: 0xFFFFFF, + emissive: 0x000000, + metalness: 1, + roughness: 1, + transparent: false, + depthTest: true, + side: FrontSide + } ); + + } + + return cache[ 'DefaultMaterial' ]; + +} + +function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) { + + // Add unknown glTF extensions to an object's userData. + + for ( const name in objectDef.extensions ) { + + if ( knownExtensions[ name ] === undefined ) { + + object.userData.gltfExtensions = object.userData.gltfExtensions || {}; + object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ]; + + } + + } + +} + +/** + * @param {Object3D|Material|BufferGeometry} object + * @param {GLTF.definition} gltfDef + */ +function assignExtrasToUserData( object, gltfDef ) { + + if ( gltfDef.extras !== undefined ) { + + if ( typeof gltfDef.extras === 'object' ) { + + Object.assign( object.userData, gltfDef.extras ); + + } else { + + console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras ); + + } + + } + +} + +/** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets + * + * @param {BufferGeometry} geometry + * @param {Array} targets + * @param {GLTFParser} parser + * @return {Promise} + */ +function addMorphTargets( geometry, targets, parser ) { + + let hasMorphPosition = false; + let hasMorphNormal = false; + let hasMorphColor = false; + + for ( let i = 0, il = targets.length; i < il; i ++ ) { + + const target = targets[ i ]; + + if ( target.POSITION !== undefined ) hasMorphPosition = true; + if ( target.NORMAL !== undefined ) hasMorphNormal = true; + if ( target.COLOR_0 !== undefined ) hasMorphColor = true; + + if ( hasMorphPosition && hasMorphNormal && hasMorphColor ) break; + + } + + if ( ! hasMorphPosition && ! hasMorphNormal && ! hasMorphColor ) return Promise.resolve( geometry ); + + const pendingPositionAccessors = []; + const pendingNormalAccessors = []; + const pendingColorAccessors = []; + + for ( let i = 0, il = targets.length; i < il; i ++ ) { + + const target = targets[ i ]; + + if ( hasMorphPosition ) { + + const pendingAccessor = target.POSITION !== undefined + ? parser.getDependency( 'accessor', target.POSITION ) + : geometry.attributes.position; + + pendingPositionAccessors.push( pendingAccessor ); + + } + + if ( hasMorphNormal ) { + + const pendingAccessor = target.NORMAL !== undefined + ? parser.getDependency( 'accessor', target.NORMAL ) + : geometry.attributes.normal; + + pendingNormalAccessors.push( pendingAccessor ); + + } + + if ( hasMorphColor ) { + + const pendingAccessor = target.COLOR_0 !== undefined + ? parser.getDependency( 'accessor', target.COLOR_0 ) + : geometry.attributes.color; + + pendingColorAccessors.push( pendingAccessor ); + + } + + } + + return Promise.all( [ + Promise.all( pendingPositionAccessors ), + Promise.all( pendingNormalAccessors ), + Promise.all( pendingColorAccessors ) + ] ).then( function ( accessors ) { + + const morphPositions = accessors[ 0 ]; + const morphNormals = accessors[ 1 ]; + const morphColors = accessors[ 2 ]; + + if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions; + if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals; + if ( hasMorphColor ) geometry.morphAttributes.color = morphColors; + geometry.morphTargetsRelative = true; + + return geometry; + + } ); + +} + +/** + * @param {Mesh} mesh + * @param {GLTF.Mesh} meshDef + */ +function updateMorphTargets( mesh, meshDef ) { + + mesh.updateMorphTargets(); + + if ( meshDef.weights !== undefined ) { + + for ( let i = 0, il = meshDef.weights.length; i < il; i ++ ) { + + mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ]; + + } + + } + + // .extras has user-defined data, so check that .extras.targetNames is an array. + if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) { + + const targetNames = meshDef.extras.targetNames; + + if ( mesh.morphTargetInfluences.length === targetNames.length ) { + + mesh.morphTargetDictionary = {}; + + for ( let i = 0, il = targetNames.length; i < il; i ++ ) { + + mesh.morphTargetDictionary[ targetNames[ i ] ] = i; + + } + + } else { + + console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' ); + + } + + } + +} + +function createPrimitiveKey( primitiveDef ) { + + let geometryKey; + + const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]; + + if ( dracoExtension ) { + + geometryKey = 'draco:' + dracoExtension.bufferView + + ':' + dracoExtension.indices + + ':' + createAttributesKey( dracoExtension.attributes ); + + } else { + + geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode; + + } + + if ( primitiveDef.targets !== undefined ) { + + for ( let i = 0, il = primitiveDef.targets.length; i < il; i ++ ) { + + geometryKey += ':' + createAttributesKey( primitiveDef.targets[ i ] ); + + } + + } + + return geometryKey; + +} + +function createAttributesKey( attributes ) { + + let attributesKey = ''; + + const keys = Object.keys( attributes ).sort(); + + for ( let i = 0, il = keys.length; i < il; i ++ ) { + + attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';'; + + } + + return attributesKey; + +} + +function getNormalizedComponentScale( constructor ) { + + // Reference: + // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data + + switch ( constructor ) { + + case Int8Array: + return 1 / 127; + + case Uint8Array: + return 1 / 255; + + case Int16Array: + return 1 / 32767; + + case Uint16Array: + return 1 / 65535; + + default: + throw new Error( 'THREE.GLTFLoader: Unsupported normalized accessor component type.' ); + + } + +} + +function getImageURIMimeType( uri ) { + + if ( uri.search( /\.jpe?g($|\?)/i ) > 0 || uri.search( /^data\:image\/jpeg/ ) === 0 ) return 'image/jpeg'; + if ( uri.search( /\.webp($|\?)/i ) > 0 || uri.search( /^data\:image\/webp/ ) === 0 ) return 'image/webp'; + + return 'image/png'; + +} + +const _identityMatrix = new Matrix4(); + +/* GLTF PARSER */ + +class GLTFParser { + + constructor( json = {}, options = {} ) { + + this.json = json; + this.extensions = {}; + this.plugins = {}; + this.options = options; + + // loader object cache + this.cache = new GLTFRegistry(); + + // associations between Three.js objects and glTF elements + this.associations = new Map(); + + // BufferGeometry caching + this.primitiveCache = {}; + + // Node cache + this.nodeCache = {}; + + // Object3D instance caches + this.meshCache = { refs: {}, uses: {} }; + this.cameraCache = { refs: {}, uses: {} }; + this.lightCache = { refs: {}, uses: {} }; + + this.sourceCache = {}; + this.textureCache = {}; + + // Track node names, to ensure no duplicates + this.nodeNamesUsed = {}; + + // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the + // expensive work of uploading a texture to the GPU off the main thread. + + let isSafari = false; + let isFirefox = false; + let firefoxVersion = - 1; + + if ( typeof navigator !== 'undefined' ) { + + isSafari = /^((?!chrome|android).)*safari/i.test( navigator.userAgent ) === true; + isFirefox = navigator.userAgent.indexOf( 'Firefox' ) > - 1; + firefoxVersion = isFirefox ? navigator.userAgent.match( /Firefox\/([0-9]+)\./ )[ 1 ] : - 1; + + } + + if ( typeof createImageBitmap === 'undefined' || isSafari || ( isFirefox && firefoxVersion < 98 ) ) { + + this.textureLoader = new TextureLoader( this.options.manager ); + + } else { + + this.textureLoader = new ImageBitmapLoader( this.options.manager ); + + } + + this.textureLoader.setCrossOrigin( this.options.crossOrigin ); + this.textureLoader.setRequestHeader( this.options.requestHeader ); + + this.fileLoader = new FileLoader( this.options.manager ); + this.fileLoader.setResponseType( 'arraybuffer' ); + + if ( this.options.crossOrigin === 'use-credentials' ) { + + this.fileLoader.setWithCredentials( true ); + + } + + } + + setExtensions( extensions ) { + + this.extensions = extensions; + + } + + setPlugins( plugins ) { + + this.plugins = plugins; + + } + + parse( onLoad, onError ) { + + const parser = this; + const json = this.json; + const extensions = this.extensions; + + // Clear the loader cache + this.cache.removeAll(); + this.nodeCache = {}; + + // Mark the special nodes/meshes in json for efficient parse + this._invokeAll( function ( ext ) { + + return ext._markDefs && ext._markDefs(); + + } ); + + Promise.all( this._invokeAll( function ( ext ) { + + return ext.beforeRoot && ext.beforeRoot(); + + } ) ).then( function () { + + return Promise.all( [ + + parser.getDependencies( 'scene' ), + parser.getDependencies( 'animation' ), + parser.getDependencies( 'camera' ), + + ] ); + + } ).then( function ( dependencies ) { + + const result = { + scene: dependencies[ 0 ][ json.scene || 0 ], + scenes: dependencies[ 0 ], + animations: dependencies[ 1 ], + cameras: dependencies[ 2 ], + asset: json.asset, + parser: parser, + userData: {} + }; + + addUnknownExtensionsToUserData( extensions, result, json ); + + assignExtrasToUserData( result, json ); + + return Promise.all( parser._invokeAll( function ( ext ) { + + return ext.afterRoot && ext.afterRoot( result ); + + } ) ).then( function () { + + for ( const scene of result.scenes ) { + + scene.updateMatrixWorld(); + + } + + onLoad( result ); + + } ); + + } ).catch( onError ); + + } + + /** + * Marks the special nodes/meshes in json for efficient parse. + */ + _markDefs() { + + const nodeDefs = this.json.nodes || []; + const skinDefs = this.json.skins || []; + const meshDefs = this.json.meshes || []; + + // Nothing in the node definition indicates whether it is a Bone or an + // Object3D. Use the skins' joint references to mark bones. + for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) { + + const joints = skinDefs[ skinIndex ].joints; + + for ( let i = 0, il = joints.length; i < il; i ++ ) { + + nodeDefs[ joints[ i ] ].isBone = true; + + } + + } + + // Iterate over all nodes, marking references to shared resources, + // as well as skeleton joints. + for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) { + + const nodeDef = nodeDefs[ nodeIndex ]; + + if ( nodeDef.mesh !== undefined ) { + + this._addNodeRef( this.meshCache, nodeDef.mesh ); + + // Nothing in the mesh definition indicates whether it is + // a SkinnedMesh or Mesh. Use the node's mesh reference + // to mark SkinnedMesh if node has skin. + if ( nodeDef.skin !== undefined ) { + + meshDefs[ nodeDef.mesh ].isSkinnedMesh = true; + + } + + } + + if ( nodeDef.camera !== undefined ) { + + this._addNodeRef( this.cameraCache, nodeDef.camera ); + + } + + } + + } + + /** + * Counts references to shared node / Object3D resources. These resources + * can be reused, or "instantiated", at multiple nodes in the scene + * hierarchy. Mesh, Camera, and Light instances are instantiated and must + * be marked. Non-scenegraph resources (like Materials, Geometries, and + * Textures) can be reused directly and are not marked here. + * + * Example: CesiumMilkTruck sample model reuses "Wheel" meshes. + */ + _addNodeRef( cache, index ) { + + if ( index === undefined ) return; + + if ( cache.refs[ index ] === undefined ) { + + cache.refs[ index ] = cache.uses[ index ] = 0; + + } + + cache.refs[ index ] ++; + + } + + /** Returns a reference to a shared resource, cloning it if necessary. */ + _getNodeRef( cache, index, object ) { + + if ( cache.refs[ index ] <= 1 ) return object; + + const ref = object.clone(); + + // Propagates mappings to the cloned object, prevents mappings on the + // original object from being lost. + const updateMappings = ( original, clone ) => { + + const mappings = this.associations.get( original ); + if ( mappings != null ) { + + this.associations.set( clone, mappings ); + + } + + for ( const [ i, child ] of original.children.entries() ) { + + updateMappings( child, clone.children[ i ] ); + + } + + }; + + updateMappings( object, ref ); + + ref.name += '_instance_' + ( cache.uses[ index ] ++ ); + + return ref; + + } + + _invokeOne( func ) { + + const extensions = Object.values( this.plugins ); + extensions.push( this ); + + for ( let i = 0; i < extensions.length; i ++ ) { + + const result = func( extensions[ i ] ); + + if ( result ) return result; + + } + + return null; + + } + + _invokeAll( func ) { + + const extensions = Object.values( this.plugins ); + extensions.unshift( this ); + + const pending = []; + + for ( let i = 0; i < extensions.length; i ++ ) { + + const result = func( extensions[ i ] ); + + if ( result ) pending.push( result ); + + } + + return pending; + + } + + /** + * Requests the specified dependency asynchronously, with caching. + * @param {string} type + * @param {number} index + * @return {Promise} + */ + getDependency( type, index ) { + + const cacheKey = type + ':' + index; + let dependency = this.cache.get( cacheKey ); + + if ( ! dependency ) { + + switch ( type ) { + + case 'scene': + dependency = this.loadScene( index ); + break; + + case 'node': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadNode && ext.loadNode( index ); + + } ); + break; + + case 'mesh': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadMesh && ext.loadMesh( index ); + + } ); + break; + + case 'accessor': + dependency = this.loadAccessor( index ); + break; + + case 'bufferView': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadBufferView && ext.loadBufferView( index ); + + } ); + break; + + case 'buffer': + dependency = this.loadBuffer( index ); + break; + + case 'material': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadMaterial && ext.loadMaterial( index ); + + } ); + break; + + case 'texture': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadTexture && ext.loadTexture( index ); + + } ); + break; + + case 'skin': + dependency = this.loadSkin( index ); + break; + + case 'animation': + dependency = this._invokeOne( function ( ext ) { + + return ext.loadAnimation && ext.loadAnimation( index ); + + } ); + break; + + case 'camera': + dependency = this.loadCamera( index ); + break; + + default: + dependency = this._invokeOne( function ( ext ) { + + return ext != this && ext.getDependency && ext.getDependency( type, index ); + + } ); + + if ( ! dependency ) { + + throw new Error( 'Unknown type: ' + type ); + + } + + break; + + } + + this.cache.add( cacheKey, dependency ); + + } + + return dependency; + + } + + /** + * Requests all dependencies of the specified type asynchronously, with caching. + * @param {string} type + * @return {Promise>} + */ + getDependencies( type ) { + + let dependencies = this.cache.get( type ); + + if ( ! dependencies ) { + + const parser = this; + const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || []; + + dependencies = Promise.all( defs.map( function ( def, index ) { + + return parser.getDependency( type, index ); + + } ) ); + + this.cache.add( type, dependencies ); + + } + + return dependencies; + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views + * @param {number} bufferIndex + * @return {Promise} + */ + loadBuffer( bufferIndex ) { + + const bufferDef = this.json.buffers[ bufferIndex ]; + const loader = this.fileLoader; + + if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) { + + throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' ); + + } + + // If present, GLB container is required to be the first buffer. + if ( bufferDef.uri === undefined && bufferIndex === 0 ) { + + return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body ); + + } + + const options = this.options; + + return new Promise( function ( resolve, reject ) { + + loader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () { + + reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) ); + + } ); + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views + * @param {number} bufferViewIndex + * @return {Promise} + */ + loadBufferView( bufferViewIndex ) { + + const bufferViewDef = this.json.bufferViews[ bufferViewIndex ]; + + return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) { + + const byteLength = bufferViewDef.byteLength || 0; + const byteOffset = bufferViewDef.byteOffset || 0; + return buffer.slice( byteOffset, byteOffset + byteLength ); + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors + * @param {number} accessorIndex + * @return {Promise} + */ + loadAccessor( accessorIndex ) { + + const parser = this; + const json = this.json; + + const accessorDef = this.json.accessors[ accessorIndex ]; + + if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) { + + const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ]; + const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]; + const normalized = accessorDef.normalized === true; + + const array = new TypedArray( accessorDef.count * itemSize ); + return Promise.resolve( new BufferAttribute( array, itemSize, normalized ) ); + + } + + const pendingBufferViews = []; + + if ( accessorDef.bufferView !== undefined ) { + + pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) ); + + } else { + + pendingBufferViews.push( null ); + + } + + if ( accessorDef.sparse !== undefined ) { + + pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) ); + pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) ); + + } + + return Promise.all( pendingBufferViews ).then( function ( bufferViews ) { + + const bufferView = bufferViews[ 0 ]; + + const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ]; + const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]; + + // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12. + const elementBytes = TypedArray.BYTES_PER_ELEMENT; + const itemBytes = elementBytes * itemSize; + const byteOffset = accessorDef.byteOffset || 0; + const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined; + const normalized = accessorDef.normalized === true; + let array, bufferAttribute; + + // The buffer is not interleaved if the stride is the item size in bytes. + if ( byteStride && byteStride !== itemBytes ) { + + // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer + // This makes sure that IBA.count reflects accessor.count properly + const ibSlice = Math.floor( byteOffset / byteStride ); + const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count; + let ib = parser.cache.get( ibCacheKey ); + + if ( ! ib ) { + + array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes ); + + // Integer parameters to IB/IBA are in array elements, not bytes. + ib = new InterleavedBuffer( array, byteStride / elementBytes ); + + parser.cache.add( ibCacheKey, ib ); + + } + + bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized ); + + } else { + + if ( bufferView === null ) { + + array = new TypedArray( accessorDef.count * itemSize ); + + } else { + + array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize ); + + } + + bufferAttribute = new BufferAttribute( array, itemSize, normalized ); + + } + + // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors + if ( accessorDef.sparse !== undefined ) { + + const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR; + const TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ]; + + const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0; + const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0; + + const sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices ); + const sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize ); + + if ( bufferView !== null ) { + + // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes. + bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized ); + + } + + for ( let i = 0, il = sparseIndices.length; i < il; i ++ ) { + + const index = sparseIndices[ i ]; + + bufferAttribute.setX( index, sparseValues[ i * itemSize ] ); + if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] ); + if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] ); + if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] ); + if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' ); + + } + + } + + return bufferAttribute; + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures + * @param {number} textureIndex + * @return {Promise} + */ + loadTexture( textureIndex ) { + + const json = this.json; + const options = this.options; + const textureDef = json.textures[ textureIndex ]; + const sourceIndex = textureDef.source; + const sourceDef = json.images[ sourceIndex ]; + + let loader = this.textureLoader; + + if ( sourceDef.uri ) { + + const handler = options.manager.getHandler( sourceDef.uri ); + if ( handler !== null ) loader = handler; + + } + + return this.loadTextureImage( textureIndex, sourceIndex, loader ); + + } + + loadTextureImage( textureIndex, sourceIndex, loader ) { + + const parser = this; + const json = this.json; + + const textureDef = json.textures[ textureIndex ]; + const sourceDef = json.images[ sourceIndex ]; + + const cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler; + + if ( this.textureCache[ cacheKey ] ) { + + // See https://github.com/mrdoob/three.js/issues/21559. + return this.textureCache[ cacheKey ]; + + } + + const promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) { + + texture.flipY = false; + + texture.name = textureDef.name || sourceDef.name || ''; + + if ( texture.name === '' && typeof sourceDef.uri === 'string' && sourceDef.uri.startsWith( 'data:image/' ) === false ) { + + texture.name = sourceDef.uri; + + } + + const samplers = json.samplers || {}; + const sampler = samplers[ textureDef.sampler ] || {}; + + texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter; + texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter; + texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping; + texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping; + + parser.associations.set( texture, { textures: textureIndex } ); + + return texture; + + } ).catch( function () { + + return null; + + } ); + + this.textureCache[ cacheKey ] = promise; + + return promise; + + } + + loadImageSource( sourceIndex, loader ) { + + const parser = this; + const json = this.json; + const options = this.options; + + if ( this.sourceCache[ sourceIndex ] !== undefined ) { + + return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() ); + + } + + const sourceDef = json.images[ sourceIndex ]; + + const URL = self.URL || self.webkitURL; + + let sourceURI = sourceDef.uri || ''; + let isObjectURL = false; + + if ( sourceDef.bufferView !== undefined ) { + + // Load binary image data from bufferView, if provided. + + sourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) { + + isObjectURL = true; + const blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } ); + sourceURI = URL.createObjectURL( blob ); + return sourceURI; + + } ); + + } else if ( sourceDef.uri === undefined ) { + + throw new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' ); + + } + + const promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) { + + return new Promise( function ( resolve, reject ) { + + let onLoad = resolve; + + if ( loader.isImageBitmapLoader === true ) { + + onLoad = function ( imageBitmap ) { + + const texture = new Texture( imageBitmap ); + texture.needsUpdate = true; + + resolve( texture ); + + }; + + } + + loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject ); + + } ); + + } ).then( function ( texture ) { + + // Clean up resources and configure Texture. + + if ( isObjectURL === true ) { + + URL.revokeObjectURL( sourceURI ); + + } + + texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri ); + + return texture; + + } ).catch( function ( error ) { + + console.error( 'THREE.GLTFLoader: Couldn\'t load texture', sourceURI ); + throw error; + + } ); + + this.sourceCache[ sourceIndex ] = promise; + return promise; + + } + + /** + * Asynchronously assigns a texture to the given material parameters. + * @param {Object} materialParams + * @param {string} mapName + * @param {Object} mapDef + * @return {Promise} + */ + assignTexture( materialParams, mapName, mapDef, colorSpace ) { + + const parser = this; + + return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) { + + if ( ! texture ) return null; + + if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) { + + texture = texture.clone(); + texture.channel = mapDef.texCoord; + + } + + if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) { + + const transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined; + + if ( transform ) { + + const gltfReference = parser.associations.get( texture ); + texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform ); + parser.associations.set( texture, gltfReference ); + + } + + } + + if ( colorSpace !== undefined ) { + + texture.colorSpace = colorSpace; + + } + + materialParams[ mapName ] = texture; + + return texture; + + } ); + + } + + /** + * Assigns final material to a Mesh, Line, or Points instance. The instance + * already has a material (generated from the glTF material options alone) + * but reuse of the same glTF material may require multiple threejs materials + * to accommodate different primitive types, defines, etc. New materials will + * be created if necessary, and reused from a cache. + * @param {Object3D} mesh Mesh, Line, or Points instance. + */ + assignFinalMaterial( mesh ) { + + const geometry = mesh.geometry; + let material = mesh.material; + + const useDerivativeTangents = geometry.attributes.tangent === undefined; + const useVertexColors = geometry.attributes.color !== undefined; + const useFlatShading = geometry.attributes.normal === undefined; + + if ( mesh.isPoints ) { + + const cacheKey = 'PointsMaterial:' + material.uuid; + + let pointsMaterial = this.cache.get( cacheKey ); + + if ( ! pointsMaterial ) { + + pointsMaterial = new PointsMaterial(); + Material.prototype.copy.call( pointsMaterial, material ); + pointsMaterial.color.copy( material.color ); + pointsMaterial.map = material.map; + pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px + + this.cache.add( cacheKey, pointsMaterial ); + + } + + material = pointsMaterial; + + } else if ( mesh.isLine ) { + + const cacheKey = 'LineBasicMaterial:' + material.uuid; + + let lineMaterial = this.cache.get( cacheKey ); + + if ( ! lineMaterial ) { + + lineMaterial = new LineBasicMaterial(); + Material.prototype.copy.call( lineMaterial, material ); + lineMaterial.color.copy( material.color ); + lineMaterial.map = material.map; + + this.cache.add( cacheKey, lineMaterial ); + + } + + material = lineMaterial; + + } + + // Clone the material if it will be modified + if ( useDerivativeTangents || useVertexColors || useFlatShading ) { + + let cacheKey = 'ClonedMaterial:' + material.uuid + ':'; + + if ( useDerivativeTangents ) cacheKey += 'derivative-tangents:'; + if ( useVertexColors ) cacheKey += 'vertex-colors:'; + if ( useFlatShading ) cacheKey += 'flat-shading:'; + + let cachedMaterial = this.cache.get( cacheKey ); + + if ( ! cachedMaterial ) { + + cachedMaterial = material.clone(); + + if ( useVertexColors ) cachedMaterial.vertexColors = true; + if ( useFlatShading ) cachedMaterial.flatShading = true; + + if ( useDerivativeTangents ) { + + // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995 + if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= - 1; + if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= - 1; + + } + + this.cache.add( cacheKey, cachedMaterial ); + + this.associations.set( cachedMaterial, this.associations.get( material ) ); + + } + + material = cachedMaterial; + + } + + mesh.material = material; + + } + + getMaterialType( /* materialIndex */ ) { + + return MeshStandardMaterial; + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials + * @param {number} materialIndex + * @return {Promise} + */ + loadMaterial( materialIndex ) { + + const parser = this; + const json = this.json; + const extensions = this.extensions; + const materialDef = json.materials[ materialIndex ]; + + let materialType; + const materialParams = {}; + const materialExtensions = materialDef.extensions || {}; + + const pending = []; + + if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) { + + const kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ]; + materialType = kmuExtension.getMaterialType(); + pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) ); + + } else { + + // Specification: + // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material + + const metallicRoughness = materialDef.pbrMetallicRoughness || {}; + + materialParams.color = new Color( 1.0, 1.0, 1.0 ); + materialParams.opacity = 1.0; + + if ( Array.isArray( metallicRoughness.baseColorFactor ) ) { + + const array = metallicRoughness.baseColorFactor; + + materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace ); + materialParams.opacity = array[ 3 ]; + + } + + if ( metallicRoughness.baseColorTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) ); + + } + + materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0; + materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0; + + if ( metallicRoughness.metallicRoughnessTexture !== undefined ) { + + pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) ); + pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) ); + + } + + materialType = this._invokeOne( function ( ext ) { + + return ext.getMaterialType && ext.getMaterialType( materialIndex ); + + } ); + + pending.push( Promise.all( this._invokeAll( function ( ext ) { + + return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams ); + + } ) ) ); + + } + + if ( materialDef.doubleSided === true ) { + + materialParams.side = DoubleSide; + + } + + const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE; + + if ( alphaMode === ALPHA_MODES.BLEND ) { + + materialParams.transparent = true; + + // See: https://github.com/mrdoob/three.js/issues/17706 + materialParams.depthWrite = false; + + } else { + + materialParams.transparent = false; + + if ( alphaMode === ALPHA_MODES.MASK ) { + + materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5; + + } + + } + + if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) { + + pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) ); + + materialParams.normalScale = new Vector2( 1, 1 ); + + if ( materialDef.normalTexture.scale !== undefined ) { + + const scale = materialDef.normalTexture.scale; + + materialParams.normalScale.set( scale, scale ); + + } + + } + + if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) { + + pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) ); + + if ( materialDef.occlusionTexture.strength !== undefined ) { + + materialParams.aoMapIntensity = materialDef.occlusionTexture.strength; + + } + + } + + if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) { + + const emissiveFactor = materialDef.emissiveFactor; + materialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace ); + + } + + if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) { + + pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) ); + + } + + return Promise.all( pending ).then( function () { + + const material = new materialType( materialParams ); + + if ( materialDef.name ) material.name = materialDef.name; + + assignExtrasToUserData( material, materialDef ); + + parser.associations.set( material, { materials: materialIndex } ); + + if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef ); + + return material; + + } ); + + } + + /** When Object3D instances are targeted by animation, they need unique names. */ + createUniqueName( originalName ) { + + const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' ); + + if ( sanitizedName in this.nodeNamesUsed ) { + + return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] ); + + } else { + + this.nodeNamesUsed[ sanitizedName ] = 0; + + return sanitizedName; + + } + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry + * + * Creates BufferGeometries from primitives. + * + * @param {Array} primitives + * @return {Promise>} + */ + loadGeometries( primitives ) { + + const parser = this; + const extensions = this.extensions; + const cache = this.primitiveCache; + + function createDracoPrimitive( primitive ) { + + return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] + .decodePrimitive( primitive, parser ) + .then( function ( geometry ) { + + return addPrimitiveAttributes( geometry, primitive, parser ); + + } ); + + } + + const pending = []; + + for ( let i = 0, il = primitives.length; i < il; i ++ ) { + + const primitive = primitives[ i ]; + const cacheKey = createPrimitiveKey( primitive ); + + // See if we've already created this geometry + const cached = cache[ cacheKey ]; + + if ( cached ) { + + // Use the cached geometry if it exists + pending.push( cached.promise ); + + } else { + + let geometryPromise; + + if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) { + + // Use DRACO geometry if available + geometryPromise = createDracoPrimitive( primitive ); + + } else { + + // Otherwise create a new geometry + geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser ); + + } + + // Cache this geometry + cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise }; + + pending.push( geometryPromise ); + + } + + } + + return Promise.all( pending ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes + * @param {number} meshIndex + * @return {Promise} + */ + loadMesh( meshIndex ) { + + const parser = this; + const json = this.json; + const extensions = this.extensions; + + const meshDef = json.meshes[ meshIndex ]; + const primitives = meshDef.primitives; + + const pending = []; + + for ( let i = 0, il = primitives.length; i < il; i ++ ) { + + const material = primitives[ i ].material === undefined + ? createDefaultMaterial( this.cache ) + : this.getDependency( 'material', primitives[ i ].material ); + + pending.push( material ); + + } + + pending.push( parser.loadGeometries( primitives ) ); + + return Promise.all( pending ).then( function ( results ) { + + const materials = results.slice( 0, results.length - 1 ); + const geometries = results[ results.length - 1 ]; + + const meshes = []; + + for ( let i = 0, il = geometries.length; i < il; i ++ ) { + + const geometry = geometries[ i ]; + const primitive = primitives[ i ]; + + // 1. create Mesh + + let mesh; + + const material = materials[ i ]; + + if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES || + primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP || + primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN || + primitive.mode === undefined ) { + + // .isSkinnedMesh isn't in glTF spec. See ._markDefs() + mesh = meshDef.isSkinnedMesh === true + ? new SkinnedMesh( geometry, material ) + : new Mesh( geometry, material ); + + if ( mesh.isSkinnedMesh === true ) { + + // normalize skin weights to fix malformed assets (see #15319) + mesh.normalizeSkinWeights(); + + } + + if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) { + + mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode ); + + } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) { + + mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode ); + + } + + } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) { + + mesh = new LineSegments( geometry, material ); + + } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) { + + mesh = new Line( geometry, material ); + + } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) { + + mesh = new LineLoop( geometry, material ); + + } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) { + + mesh = new Points( geometry, material ); + + } else { + + throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode ); + + } + + if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) { + + updateMorphTargets( mesh, meshDef ); + + } + + mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) ); + + assignExtrasToUserData( mesh, meshDef ); + + if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive ); + + parser.assignFinalMaterial( mesh ); + + meshes.push( mesh ); + + } + + for ( let i = 0, il = meshes.length; i < il; i ++ ) { + + parser.associations.set( meshes[ i ], { + meshes: meshIndex, + primitives: i + } ); + + } + + if ( meshes.length === 1 ) { + + if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, meshes[ 0 ], meshDef ); + + return meshes[ 0 ]; + + } + + const group = new Group(); + + if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, group, meshDef ); + + parser.associations.set( group, { meshes: meshIndex } ); + + for ( let i = 0, il = meshes.length; i < il; i ++ ) { + + group.add( meshes[ i ] ); + + } + + return group; + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras + * @param {number} cameraIndex + * @return {Promise} + */ + loadCamera( cameraIndex ) { + + let camera; + const cameraDef = this.json.cameras[ cameraIndex ]; + const params = cameraDef[ cameraDef.type ]; + + if ( ! params ) { + + console.warn( 'THREE.GLTFLoader: Missing camera parameters.' ); + return; + + } + + if ( cameraDef.type === 'perspective' ) { + + camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 ); + + } else if ( cameraDef.type === 'orthographic' ) { + + camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar ); + + } + + if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name ); + + assignExtrasToUserData( camera, cameraDef ); + + return Promise.resolve( camera ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins + * @param {number} skinIndex + * @return {Promise} + */ + loadSkin( skinIndex ) { + + const skinDef = this.json.skins[ skinIndex ]; + + const pending = []; + + for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) { + + pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) ); + + } + + if ( skinDef.inverseBindMatrices !== undefined ) { + + pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) ); + + } else { + + pending.push( null ); + + } + + return Promise.all( pending ).then( function ( results ) { + + const inverseBindMatrices = results.pop(); + const jointNodes = results; + + // Note that bones (joint nodes) may or may not be in the + // scene graph at this time. + + const bones = []; + const boneInverses = []; + + for ( let i = 0, il = jointNodes.length; i < il; i ++ ) { + + const jointNode = jointNodes[ i ]; + + if ( jointNode ) { + + bones.push( jointNode ); + + const mat = new Matrix4(); + + if ( inverseBindMatrices !== null ) { + + mat.fromArray( inverseBindMatrices.array, i * 16 ); + + } + + boneInverses.push( mat ); + + } else { + + console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] ); + + } + + } + + return new Skeleton( bones, boneInverses ); + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations + * @param {number} animationIndex + * @return {Promise} + */ + loadAnimation( animationIndex ) { + + const json = this.json; + const parser = this; + + const animationDef = json.animations[ animationIndex ]; + const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex; + + const pendingNodes = []; + const pendingInputAccessors = []; + const pendingOutputAccessors = []; + const pendingSamplers = []; + const pendingTargets = []; + + for ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) { + + const channel = animationDef.channels[ i ]; + const sampler = animationDef.samplers[ channel.sampler ]; + const target = channel.target; + const name = target.node; + const input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input; + const output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output; + + if ( target.node === undefined ) continue; + + pendingNodes.push( this.getDependency( 'node', name ) ); + pendingInputAccessors.push( this.getDependency( 'accessor', input ) ); + pendingOutputAccessors.push( this.getDependency( 'accessor', output ) ); + pendingSamplers.push( sampler ); + pendingTargets.push( target ); + + } + + return Promise.all( [ + + Promise.all( pendingNodes ), + Promise.all( pendingInputAccessors ), + Promise.all( pendingOutputAccessors ), + Promise.all( pendingSamplers ), + Promise.all( pendingTargets ) + + ] ).then( function ( dependencies ) { + + const nodes = dependencies[ 0 ]; + const inputAccessors = dependencies[ 1 ]; + const outputAccessors = dependencies[ 2 ]; + const samplers = dependencies[ 3 ]; + const targets = dependencies[ 4 ]; + + const tracks = []; + + for ( let i = 0, il = nodes.length; i < il; i ++ ) { + + const node = nodes[ i ]; + const inputAccessor = inputAccessors[ i ]; + const outputAccessor = outputAccessors[ i ]; + const sampler = samplers[ i ]; + const target = targets[ i ]; + + if ( node === undefined ) continue; + + if ( node.updateMatrix ) { + + node.updateMatrix(); + + } + + const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ); + + if ( createdTracks ) { + + for ( let k = 0; k < createdTracks.length; k ++ ) { + + tracks.push( createdTracks[ k ] ); + + } + + } + + } + + return new AnimationClip( animationName, undefined, tracks ); + + } ); + + } + + createNodeMesh( nodeIndex ) { + + const json = this.json; + const parser = this; + const nodeDef = json.nodes[ nodeIndex ]; + + if ( nodeDef.mesh === undefined ) return null; + + return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) { + + const node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh ); + + // if weights are provided on the node, override weights on the mesh. + if ( nodeDef.weights !== undefined ) { + + node.traverse( function ( o ) { + + if ( ! o.isMesh ) return; + + for ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) { + + o.morphTargetInfluences[ i ] = nodeDef.weights[ i ]; + + } + + } ); + + } + + return node; + + } ); + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy + * @param {number} nodeIndex + * @return {Promise} + */ + loadNode( nodeIndex ) { + + const json = this.json; + const parser = this; + + const nodeDef = json.nodes[ nodeIndex ]; + + const nodePending = parser._loadNodeShallow( nodeIndex ); + + const childPending = []; + const childrenDef = nodeDef.children || []; + + for ( let i = 0, il = childrenDef.length; i < il; i ++ ) { + + childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) ); + + } + + const skeletonPending = nodeDef.skin === undefined + ? Promise.resolve( null ) + : parser.getDependency( 'skin', nodeDef.skin ); + + return Promise.all( [ + nodePending, + Promise.all( childPending ), + skeletonPending + ] ).then( function ( results ) { + + const node = results[ 0 ]; + const children = results[ 1 ]; + const skeleton = results[ 2 ]; + + if ( skeleton !== null ) { + + // This full traverse should be fine because + // child glTF nodes have not been added to this node yet. + node.traverse( function ( mesh ) { + + if ( ! mesh.isSkinnedMesh ) return; + + mesh.bind( skeleton, _identityMatrix ); + + } ); + + } + + for ( let i = 0, il = children.length; i < il; i ++ ) { + + node.add( children[ i ] ); + + } + + return node; + + } ); + + } + + // ._loadNodeShallow() parses a single node. + // skin and child nodes are created and added in .loadNode() (no '_' prefix). + _loadNodeShallow( nodeIndex ) { + + const json = this.json; + const extensions = this.extensions; + const parser = this; + + // This method is called from .loadNode() and .loadSkin(). + // Cache a node to avoid duplication. + + if ( this.nodeCache[ nodeIndex ] !== undefined ) { + + return this.nodeCache[ nodeIndex ]; + + } + + const nodeDef = json.nodes[ nodeIndex ]; + + // reserve node's name before its dependencies, so the root has the intended name. + const nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : ''; + + const pending = []; + + const meshPromise = parser._invokeOne( function ( ext ) { + + return ext.createNodeMesh && ext.createNodeMesh( nodeIndex ); + + } ); + + if ( meshPromise ) { + + pending.push( meshPromise ); + + } + + if ( nodeDef.camera !== undefined ) { + + pending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) { + + return parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera ); + + } ) ); + + } + + parser._invokeAll( function ( ext ) { + + return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex ); + + } ).forEach( function ( promise ) { + + pending.push( promise ); + + } ); + + this.nodeCache[ nodeIndex ] = Promise.all( pending ).then( function ( objects ) { + + let node; + + // .isBone isn't in glTF spec. See ._markDefs + if ( nodeDef.isBone === true ) { + + node = new Bone(); + + } else if ( objects.length > 1 ) { + + node = new Group(); + + } else if ( objects.length === 1 ) { + + node = objects[ 0 ]; + + } else { + + node = new Object3D(); + + } + + if ( node !== objects[ 0 ] ) { + + for ( let i = 0, il = objects.length; i < il; i ++ ) { + + node.add( objects[ i ] ); + + } + + } + + if ( nodeDef.name ) { + + node.userData.name = nodeDef.name; + node.name = nodeName; + + } + + assignExtrasToUserData( node, nodeDef ); + + if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef ); + + if ( nodeDef.matrix !== undefined ) { + + const matrix = new Matrix4(); + matrix.fromArray( nodeDef.matrix ); + node.applyMatrix4( matrix ); + + } else { + + if ( nodeDef.translation !== undefined ) { + + node.position.fromArray( nodeDef.translation ); + + } + + if ( nodeDef.rotation !== undefined ) { + + node.quaternion.fromArray( nodeDef.rotation ); + + } + + if ( nodeDef.scale !== undefined ) { + + node.scale.fromArray( nodeDef.scale ); + + } + + } + + if ( ! parser.associations.has( node ) ) { + + parser.associations.set( node, {} ); + + } + + parser.associations.get( node ).nodes = nodeIndex; + + return node; + + } ); + + return this.nodeCache[ nodeIndex ]; + + } + + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes + * @param {number} sceneIndex + * @return {Promise} + */ + loadScene( sceneIndex ) { + + const extensions = this.extensions; + const sceneDef = this.json.scenes[ sceneIndex ]; + const parser = this; + + // Loader returns Group, not Scene. + // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172 + const scene = new Group(); + if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name ); + + assignExtrasToUserData( scene, sceneDef ); + + if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef ); + + const nodeIds = sceneDef.nodes || []; + + const pending = []; + + for ( let i = 0, il = nodeIds.length; i < il; i ++ ) { + + pending.push( parser.getDependency( 'node', nodeIds[ i ] ) ); + + } + + return Promise.all( pending ).then( function ( nodes ) { + + for ( let i = 0, il = nodes.length; i < il; i ++ ) { + + scene.add( nodes[ i ] ); + + } + + // Removes dangling associations, associations that reference a node that + // didn't make it into the scene. + const reduceAssociations = ( node ) => { + + const reducedAssociations = new Map(); + + for ( const [ key, value ] of parser.associations ) { + + if ( key instanceof Material || key instanceof Texture ) { + + reducedAssociations.set( key, value ); + + } + + } + + node.traverse( ( node ) => { + + const mappings = parser.associations.get( node ); + + if ( mappings != null ) { + + reducedAssociations.set( node, mappings ); + + } + + } ); + + return reducedAssociations; + + }; + + parser.associations = reduceAssociations( scene ); + + return scene; + + } ); + + } + + _createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) { + + const tracks = []; + + const targetName = node.name ? node.name : node.uuid; + const targetNames = []; + + if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) { + + node.traverse( function ( object ) { + + if ( object.morphTargetInfluences ) { + + targetNames.push( object.name ? object.name : object.uuid ); + + } + + } ); + + } else { + + targetNames.push( targetName ); + + } + + let TypedKeyframeTrack; + + switch ( PATH_PROPERTIES[ target.path ] ) { + + case PATH_PROPERTIES.weights: + + TypedKeyframeTrack = NumberKeyframeTrack; + break; + + case PATH_PROPERTIES.rotation: + + TypedKeyframeTrack = QuaternionKeyframeTrack; + break; + + case PATH_PROPERTIES.position: + case PATH_PROPERTIES.scale: + + TypedKeyframeTrack = VectorKeyframeTrack; + break; + + default: + + switch ( outputAccessor.itemSize ) { + + case 1: + TypedKeyframeTrack = NumberKeyframeTrack; + break; + case 2: + case 3: + default: + TypedKeyframeTrack = VectorKeyframeTrack; + break; + + } + + break; + + } + + const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear; + + + const outputArray = this._getArrayFromAccessor( outputAccessor ); + + for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) { + + const track = new TypedKeyframeTrack( + targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ], + inputAccessor.array, + outputArray, + interpolation + ); + + // Override interpolation with custom factory method. + if ( sampler.interpolation === 'CUBICSPLINE' ) { + + this._createCubicSplineTrackInterpolant( track ); + + } + + tracks.push( track ); + + } + + return tracks; + + } + + _getArrayFromAccessor( accessor ) { + + let outputArray = accessor.array; + + if ( accessor.normalized ) { + + const scale = getNormalizedComponentScale( outputArray.constructor ); + const scaled = new Float32Array( outputArray.length ); + + for ( let j = 0, jl = outputArray.length; j < jl; j ++ ) { + + scaled[ j ] = outputArray[ j ] * scale; + + } + + outputArray = scaled; + + } + + return outputArray; + + } + + _createCubicSplineTrackInterpolant( track ) { + + track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) { + + // A CUBICSPLINE keyframe in glTF has three output values for each input value, + // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize() + // must be divided by three to get the interpolant's sampleSize argument. + + const interpolantType = ( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant; + + return new interpolantType( this.times, this.values, this.getValueSize() / 3, result ); + + }; + + // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants. + track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true; + + } + +} + +/** + * @param {BufferGeometry} geometry + * @param {GLTF.Primitive} primitiveDef + * @param {GLTFParser} parser + */ +function computeBounds( geometry, primitiveDef, parser ) { + + const attributes = primitiveDef.attributes; + + const box = new Box3(); + + if ( attributes.POSITION !== undefined ) { + + const accessor = parser.json.accessors[ attributes.POSITION ]; + + const min = accessor.min; + const max = accessor.max; + + // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement. + + if ( min !== undefined && max !== undefined ) { + + box.set( + new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ), + new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] ) + ); + + if ( accessor.normalized ) { + + const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] ); + box.min.multiplyScalar( boxScale ); + box.max.multiplyScalar( boxScale ); + + } + + } else { + + console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' ); + + return; + + } + + } else { + + return; + + } + + const targets = primitiveDef.targets; + + if ( targets !== undefined ) { + + const maxDisplacement = new Vector3(); + const vector = new Vector3(); + + for ( let i = 0, il = targets.length; i < il; i ++ ) { + + const target = targets[ i ]; + + if ( target.POSITION !== undefined ) { + + const accessor = parser.json.accessors[ target.POSITION ]; + const min = accessor.min; + const max = accessor.max; + + // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement. + + if ( min !== undefined && max !== undefined ) { + + // we need to get max of absolute components because target weight is [-1,1] + vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) ); + vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) ); + vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) ); + + + if ( accessor.normalized ) { + + const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] ); + vector.multiplyScalar( boxScale ); + + } + + // Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative + // to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets + // are used to implement key-frame animations and as such only two are active at a time - this results in very large + // boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size. + maxDisplacement.max( vector ); + + } else { + + console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' ); + + } + + } + + } + + // As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets. + box.expandByVector( maxDisplacement ); + + } + + geometry.boundingBox = box; + + const sphere = new Sphere(); + + box.getCenter( sphere.center ); + sphere.radius = box.min.distanceTo( box.max ) / 2; + + geometry.boundingSphere = sphere; + +} + +/** + * @param {BufferGeometry} geometry + * @param {GLTF.Primitive} primitiveDef + * @param {GLTFParser} parser + * @return {Promise} + */ +function addPrimitiveAttributes( geometry, primitiveDef, parser ) { + + const attributes = primitiveDef.attributes; + + const pending = []; + + function assignAttributeAccessor( accessorIndex, attributeName ) { + + return parser.getDependency( 'accessor', accessorIndex ) + .then( function ( accessor ) { + + geometry.setAttribute( attributeName, accessor ); + + } ); + + } + + for ( const gltfAttributeName in attributes ) { + + const threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase(); + + // Skip attributes already provided by e.g. Draco extension. + if ( threeAttributeName in geometry.attributes ) continue; + + pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) ); + + } + + if ( primitiveDef.indices !== undefined && ! geometry.index ) { + + const accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) { + + geometry.setIndex( accessor ); + + } ); + + pending.push( accessor ); + + } + + if ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) { + + console.warn( `THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.` ); + + } + + assignExtrasToUserData( geometry, primitiveDef ); + + computeBounds( geometry, primitiveDef, parser ); + + return Promise.all( pending ).then( function () { + + return primitiveDef.targets !== undefined + ? addMorphTargets( geometry, primitiveDef.targets, parser ) + : geometry; + + } ); + +} + +export { GLTFLoader }; diff --git a/seminar06-planning/simulator/js/objects/MapObject.js b/seminar06-planning/simulator/js/objects/MapObject.js new file mode 100644 index 0000000..e895f70 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/MapObject.js @@ -0,0 +1,68 @@ +// geolocation = [33.523900, -111.908756]; +export default class MapObject extends THREE.Object3D { + constructor(geolocation = null) { + super(); + + this.geolocation = geolocation; + this.tilesGroup = null; + + const tileSize = geolocation ? this.tileSizeInMeters() : 10; + const grid = new THREE.GridHelper(MapObject.HALF_NUM_TILES * 8 * tileSize, MapObject.HALF_NUM_TILES * 8, 0x333333, 0x333333); + grid.renderOrder = -1; + grid.material.depthTest = false; + grid.position.add(new THREE.Vector3(-tileSize / 2, 0, -tileSize / 2)); + this.add(grid); + + if (geolocation) + this.drawTiles(); + } + + // Converts lat-long geolocation to Google Maps world coodinates + static geoToWorld(latlng) { + const latitudeRadians = latlng[0] * Math.PI / 180; + const x = (latlng[1] + 180) / 360 * 256; + const y = ((1 - Math.log(Math.tan(latitudeRadians) + 1 / Math.cos(latitudeRadians)) / Math.PI) / 2) * 256; + return [x, y]; + } + + // Calculates the x and y tile indices for the provided world coordinates + static worldToTile(worldCoordinates) { + return [Math.floor(worldCoordinates[0] * MapObject.SCALE / 256), Math.floor(worldCoordinates[1] * MapObject.SCALE / 256)]; + } + + drawTiles() { + if (this.tileGroup != null) this.remove(this.tilesGroup); + this.tileGroup = new THREE.Group(); + + const originTile = MapObject.worldToTile(MapObject.geoToWorld(this.geolocation)); + const tileSize = this.tileSizeInMeters(); + + for (let x = -MapObject.HALF_NUM_TILES, h = 0; x < MapObject.HALF_NUM_TILES; x++) { + for (let y = -MapObject.HALF_NUM_TILES; y < MapObject.HALF_NUM_TILES; y++, h++) { + 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}`); + tileTexture.anisotropy = 16; + const tileGeometry = new THREE.PlaneBufferGeometry(tileSize, tileSize); + const tileMaterial = new THREE.MeshBasicMaterial({ map: tileTexture, color: 0xffffff }); + const tile = new THREE.Mesh(tileGeometry, tileMaterial); + tile.rotation.x = -Math.PI / 2; + tile.position.x = x * tileSize; + tile.position.z = y * tileSize; + + this.tileGroup.add(tile); + } + } + + this.add(this.tileGroup); + } + + tileSizeInMeters() { + // Because of the Mercator projection used to create the tile images, the size of a tile (in meters) depends on the latitude + return 2 * Math.PI * MapObject.EARTH_RADIUS * Math.cos(this.geolocation[0] * Math.PI / 180) / Math.pow(2, MapObject.ZOOM); + } +} + +MapObject.EARTH_RADIUS = 6378137; // meters +MapObject.TILE_PIXELS = 256; // pixels per tile +MapObject.ZOOM = 20; +MapObject.SCALE = 1 << MapObject.ZOOM; +MapObject.HALF_NUM_TILES = 20; diff --git a/seminar06-planning/simulator/js/objects/StaticObstacleObject.js b/seminar06-planning/simulator/js/objects/StaticObstacleObject.js new file mode 100644 index 0000000..3093662 --- /dev/null +++ b/seminar06-planning/simulator/js/objects/StaticObstacleObject.js @@ -0,0 +1,32 @@ +const COLOR = 0xdd0000; +const HEIGHT = 5; + +export default class StaticObstacleObject extends THREE.Object3D { + constructor(staticObstacle) { + super(); + + const mesh2D = new THREE.Mesh( + new THREE.PlaneGeometry(staticObstacle.width, staticObstacle.height), + new THREE.MeshBasicMaterial({ color: COLOR, depthTest: false, transparent: true, opacity: 0.5 }) + ); + mesh2D.rotation.x = -Math.PI / 2; + mesh2D.layers.set(2); + this.add(mesh2D); + + const stoneTexture = new THREE.TextureLoader().load('http://127.0.0.1:8008/images/stone.jpg'); + stoneTexture.wrapS = THREE.RepeatWrapping + stoneTexture.wrapT = THREE.RepeatWrapping + stoneTexture.magFilter = THREE.NearestFilter + + const mesh3D = new THREE.Mesh( + new THREE.BoxBufferGeometry(staticObstacle.width, HEIGHT, staticObstacle.height), + new THREE.MeshToonMaterial({ map: stoneTexture, transparent: true, opacity: 0.9 }) + ); + mesh3D.position.setY(HEIGHT / 2); + mesh3D.layers.set(3); + this.add(mesh3D); + + this.rotation.y = -staticObstacle.rot; + this.position.set(staticObstacle.pos.x, 0, staticObstacle.pos.y); + } +} diff --git a/seminar06-planning/simulator/js/objects/TDSLoader.js b/seminar06-planning/simulator/js/objects/TDSLoader.js new file mode 100644 index 0000000..9ab44db --- /dev/null +++ b/seminar06-planning/simulator/js/objects/TDSLoader.js @@ -0,0 +1,1145 @@ +/* + * Autodesk 3DS threee.js file loader, based on lib3ds. + * + * Loads geometry with uv and materials basic properties with texture support. + * + * @author @tentone + * @author @timknip + * @class TDSLoader + * @constructor + */ + +'use strict'; + +THREE.TDSLoader = function ( manager ) { + + this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; + this.debug = false; + + this.group = null; + this.position = 0; + + this.materials = []; + this.meshes = []; + +}; + +THREE.TDSLoader.prototype = { + + constructor: THREE.TDSLoader, + + /** + * Load 3ds file from url. + * + * @method load + * @param {[type]} url URL for the file. + * @param {Function} onLoad onLoad callback, receives group Object3D as argument. + * @param {Function} onProgress onProgress callback. + * @param {Function} onError onError callback. + */ + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var path = this.path !== undefined ? this.path : THREE.LoaderUtils.extractUrlBase( url ); + + var loader = new THREE.FileLoader( this.manager ); + + loader.setResponseType( 'arraybuffer' ); + + loader.load( url, function ( data ) { + + onLoad( scope.parse( data, path ) ); + + }, onProgress, onError ); + + }, + + /** + * Parse arraybuffer data and load 3ds file. + * + * @method parse + * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded. + * @param {String} path Path for external resources. + * @return {Object3D} Group loaded from 3ds file. + */ + parse: function ( arraybuffer, path ) { + + this.group = new THREE.Group(); + this.position = 0; + this.materials = []; + this.meshes = []; + + this.readFile( arraybuffer, path ); + + for ( var i = 0; i < this.meshes.length; i ++ ) { + + this.group.add( this.meshes[ i ] ); + + } + + return this.group; + + }, + + /** + * Decode file content to read 3ds data. + * + * @method readFile + * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded. + */ + readFile: function ( arraybuffer, path ) { + + var data = new DataView( arraybuffer ); + var chunk = this.readChunk( data ); + + if ( chunk.id === MLIBMAGIC || chunk.id === CMAGIC || chunk.id === M3DMAGIC ) { + + var next = this.nextChunk( data, chunk ); + + while ( next !== 0 ) { + + if ( next === M3D_VERSION ) { + + var version = this.readDWord( data ); + this.debugMessage( '3DS file version: ' + version ); + + } else if ( next === MDATA ) { + + this.resetPosition( data ); + this.readMeshData( data, path ); + + } else { + + this.debugMessage( 'Unknown main chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + } + + this.debugMessage( 'Parsed ' + this.meshes.length + ' meshes' ); + + }, + + /** + * Read mesh data chunk. + * + * @method readMeshData + * @param {Dataview} data Dataview in use. + */ + readMeshData: function ( data, path ) { + + var chunk = this.readChunk( data ); + var next = this.nextChunk( data, chunk ); + + while ( next !== 0 ) { + + if ( next === MESH_VERSION ) { + + var version = + this.readDWord( data ); + this.debugMessage( 'Mesh Version: ' + version ); + + } else if ( next === MASTER_SCALE ) { + + var scale = this.readFloat( data ); + this.debugMessage( 'Master scale: ' + scale ); + this.group.scale.set( scale, scale, scale ); + + } else if ( next === NAMED_OBJECT ) { + + this.debugMessage( 'Named Object' ); + this.resetPosition( data ); + this.readNamedObject( data ); + + } else if ( next === MAT_ENTRY ) { + + this.debugMessage( 'Material' ); + this.resetPosition( data ); + this.readMaterialEntry( data, path ); + + } else { + + this.debugMessage( 'Unknown MDATA chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + }, + + /** + * Read named object chunk. + * + * @method readNamedObject + * @param {Dataview} data Dataview in use. + */ + readNamedObject: function ( data ) { + + var chunk = this.readChunk( data ); + var name = this.readString( data, 64 ); + chunk.cur = this.position; + + var next = this.nextChunk( data, chunk ); + while ( next !== 0 ) { + + if ( next === N_TRI_OBJECT ) { + + this.resetPosition( data ); + var mesh = this.readMesh( data ); + mesh.name = name; + this.meshes.push( mesh ); + + } else { + + this.debugMessage( 'Unknown named object chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + this.endChunk( chunk ); + + }, + + /** + * Read material data chunk and add it to the material list. + * + * @method readMaterialEntry + * @param {Dataview} data Dataview in use. + */ + readMaterialEntry: function ( data, path ) { + + var chunk = this.readChunk( data ); + var next = this.nextChunk( data, chunk ); + var material = new THREE.MeshPhongMaterial(); + + while ( next !== 0 ) { + + if ( next === MAT_NAME ) { + + material.name = this.readString( data, 64 ); + this.debugMessage( ' Name: ' + material.name ); + + } else if ( next === MAT_WIRE ) { + + this.debugMessage( ' Wireframe' ); + material.wireframe = true; + + } else if ( next === MAT_WIRE_SIZE ) { + + var value = this.readByte( data ); + material.wireframeLinewidth = value; + this.debugMessage( ' Wireframe Thickness: ' + value ); + + } else if ( next === MAT_TWO_SIDE ) { + + material.side = THREE.DoubleSide; + this.debugMessage( ' DoubleSided' ); + + } else if ( next === MAT_ADDITIVE ) { + + this.debugMessage( ' Additive Blending' ); + material.blending = THREE.AdditiveBlending; + + } else if ( next === MAT_DIFFUSE ) { + + this.debugMessage( ' Diffuse Color' ); + material.color = this.readColor( data ); + + } else if ( next === MAT_SPECULAR ) { + + this.debugMessage( ' Specular Color' ); + material.specular = this.readColor( data ); + + } else if ( next === MAT_AMBIENT ) { + + this.debugMessage( ' Ambient color' ); + material.color = this.readColor( data ); + + } else if ( next === MAT_SHININESS ) { + + var shininess = this.readWord( data ); + material.shininess = shininess; + this.debugMessage( ' Shininess : ' + shininess ); + + } else if ( next === MAT_TEXMAP ) { + + this.debugMessage( ' ColorMap' ); + this.resetPosition( data ); + material.map = this.readMap( data, path ); + + } else if ( next === MAT_BUMPMAP ) { + + this.debugMessage( ' BumpMap' ); + this.resetPosition( data ); + material.bumpMap = this.readMap( data, path ); + + } else if ( next === MAT_OPACMAP ) { + + this.debugMessage( ' OpacityMap' ); + this.resetPosition( data ); + material.alphaMap = this.readMap( data, path ); + + } else if ( next === MAT_SPECMAP ) { + + this.debugMessage( ' SpecularMap' ); + this.resetPosition( data ); + material.specularMap = this.readMap( data, path ); + + } else { + + this.debugMessage( ' Unknown material chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + this.endChunk( chunk ); + + this.materials[ material.name ] = material; + + }, + + /** + * Read mesh data chunk. + * + * @method readMesh + * @param {Dataview} data Dataview in use. + */ + readMesh: function ( data ) { + + var chunk = this.readChunk( data ); + var next = this.nextChunk( data, chunk ); + + var useBufferGeometry = false; + var geometry = null; + var uvs = []; + + if ( useBufferGeometry ) { + + geometry = new THREE.BufferGeometry(); + + } else { + + geometry = new THREE.Geometry(); + + } + + var material = new THREE.MeshPhongMaterial(); + var mesh = new THREE.Mesh( geometry, material ); + mesh.name = 'mesh'; + + while ( next !== 0 ) { + + if ( next === POINT_ARRAY ) { + + var points = this.readWord( data ); + + this.debugMessage( ' Vertex: ' + points ); + + //BufferGeometry + + if ( useBufferGeometry ) { + + var vertices = []; + for ( var i = 0; i < points; i ++ ) { + + vertices.push( this.readFloat( data ) ); + vertices.push( this.readFloat( data ) ); + vertices.push( this.readFloat( data ) ); + + } + + geometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) ); + + } else { //Geometry + + for ( var i = 0; i < points; i ++ ) { + + geometry.vertices.push( new THREE.Vector3( this.readFloat( data ), this.readFloat( data ), this.readFloat( data ) ) ); + + } + + } + + } else if ( next === FACE_ARRAY ) { + + this.resetPosition( data ); + this.readFaceArray( data, mesh ); + + } else if ( next === TEX_VERTS ) { + + var texels = this.readWord( data ); + + this.debugMessage( ' UV: ' + texels ); + + //BufferGeometry + + if ( useBufferGeometry ) { + + var uvs = []; + for ( var i = 0; i < texels; i ++ ) { + + uvs.push( this.readFloat( data ) ); + uvs.push( this.readFloat( data ) ); + + } + geometry.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( uvs ), 2 ) ); + + } else { //Geometry + + uvs = []; + for ( var i = 0; i < texels; i ++ ) { + + uvs.push( new THREE.Vector2( this.readFloat( data ), this.readFloat( data ) ) ); + + } + + } + + } else if ( next === MESH_MATRIX ) { + + this.debugMessage( ' Tranformation Matrix (TODO)' ); + + var values = []; + for ( var i = 0; i < 12; i ++ ) { + + values[ i ] = this.readFloat( data ); + + } + + var matrix = new THREE.Matrix4(); + + //X Line + matrix.elements[ 0 ] = values[ 0 ]; + matrix.elements[ 1 ] = values[ 6 ]; + matrix.elements[ 2 ] = values[ 3 ]; + matrix.elements[ 3 ] = values[ 9 ]; + + //Y Line + matrix.elements[ 4 ] = values[ 2 ]; + matrix.elements[ 5 ] = values[ 8 ]; + matrix.elements[ 6 ] = values[ 5 ]; + matrix.elements[ 7 ] = values[ 11 ]; + + //Z Line + matrix.elements[ 8 ] = values[ 1 ]; + matrix.elements[ 9 ] = values[ 7 ]; + matrix.elements[ 10 ] = values[ 4 ]; + matrix.elements[ 11 ] = values[ 10 ]; + + //W Line + matrix.elements[ 12 ] = 0; + matrix.elements[ 13 ] = 0; + matrix.elements[ 14 ] = 0; + matrix.elements[ 15 ] = 1; + + matrix.transpose(); + + var inverse = new THREE.Matrix4(); + inverse.getInverse( matrix, true ); + geometry.applyMatrix( inverse ); + + matrix.decompose( mesh.position, mesh.quaternion, mesh.scale ); + + } else { + + this.debugMessage( ' Unknown mesh chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + this.endChunk( chunk ); + + if ( ! useBufferGeometry ) { + + //geometry.faceVertexUvs[0][faceIndex][vertexIndex] + + if ( uvs.length > 0 ) { + + var faceUV = []; + + for ( var i = 0; i < geometry.faces.length; i ++ ) { + + faceUV.push( [ uvs[ geometry.faces[ i ].a ], uvs[ geometry.faces[ i ].b ], uvs[ geometry.faces[ i ].c ] ] ); + + } + + geometry.faceVertexUvs[ 0 ] = faceUV; + + } + + geometry.computeVertexNormals(); + + } + + return mesh; + + }, + + /** + * Read face array data chunk. + * + * @method readFaceArray + * @param {Dataview} data Dataview in use. + * @param {Mesh} mesh Mesh to be filled with the data read. + */ + readFaceArray: function ( data, mesh ) { + + var chunk = this.readChunk( data ); + var faces = this.readWord( data ); + + this.debugMessage( ' Faces: ' + faces ); + + for ( var i = 0; i < faces; ++ i ) { + + mesh.geometry.faces.push( new THREE.Face3( this.readWord( data ), this.readWord( data ), this.readWord( data ) ) ); + + var visibility = this.readWord( data ); + + } + + //The rest of the FACE_ARRAY chunk is subchunks + + while ( this.position < chunk.end ) { + + var chunk = this.readChunk( data ); + + if ( chunk.id === MSH_MAT_GROUP ) { + + this.debugMessage( ' Material Group' ); + + this.resetPosition( data ); + + var group = this.readMaterialGroup( data ); + + var material = this.materials[ group.name ]; + + if ( material !== undefined ) { + + mesh.material = material; + + if ( material.name === '' ) { + + material.name = mesh.name; + + } + + } + + } else { + + this.debugMessage( ' Unknown face array chunk: ' + chunk.toString( 16 ) ); + + } + + this.endChunk( chunk ); + + } + + this.endChunk( chunk ); + + }, + + /** + * Read texture map data chunk. + * + * @method readMap + * @param {Dataview} data Dataview in use. + * @return {Texture} Texture read from this data chunk. + */ + readMap: function ( data, path ) { + if (this.skipMaps) return null; + + var chunk = this.readChunk( data ); + var next = this.nextChunk( data, chunk ); + var texture = {}; + + var loader = new THREE.TextureLoader( this.manager ); + loader.setPath( path ); + + while ( next !== 0 ) { + + if ( next === MAT_MAPNAME ) { + + var name = this.readString( data, 128 ); + texture = loader.load( name ); + + this.debugMessage( ' File: ' + path + name ); + + } else if ( next === MAT_MAP_UOFFSET ) { + + texture.offset.x = this.readFloat( data ); + this.debugMessage( ' OffsetX: ' + texture.offset.x ); + + } else if ( next === MAT_MAP_VOFFSET ) { + + texture.offset.y = this.readFloat( data ); + this.debugMessage( ' OffsetY: ' + texture.offset.y ); + + } else if ( next === MAT_MAP_USCALE ) { + + texture.repeat.x = this.readFloat( data ); + this.debugMessage( ' RepeatX: ' + texture.repeat.x ); + + } else if ( next === MAT_MAP_VSCALE ) { + + texture.repeat.y = this.readFloat( data ); + this.debugMessage( ' RepeatY: ' + texture.repeat.y ); + + } else { + + this.debugMessage( ' Unknown map chunk: ' + next.toString( 16 ) ); + + } + + next = this.nextChunk( data, chunk ); + + } + + this.endChunk( chunk ); + + return texture; + + }, + + /** + * Read material group data chunk. + * + * @method readMaterialGroup + * @param {Dataview} data Dataview in use. + * @return {Object} Object with name and index of the object. + */ + readMaterialGroup: function ( data ) { + + var chunk = this.readChunk( data ); + var name = this.readString( data, 64 ); + var numFaces = this.readWord( data ); + + this.debugMessage( ' Name: ' + name ); + this.debugMessage( ' Faces: ' + numFaces ); + + var index = []; + for ( var i = 0; i < numFaces; ++ i ) { + + index.push( this.readWord( data ) ); + + } + + return { name: name, index: index }; + + }, + + /** + * Read a color value. + * + * @method readColor + * @param {DataView} data Dataview. + * @return {Color} Color value read.. + */ + readColor: function ( data ) { + + var chunk = this.readChunk( data ); + var color = new THREE.Color(); + + if ( chunk.id === COLOR_24 || chunk.id === LIN_COLOR_24 ) { + + var r = this.readByte( data ); + var g = this.readByte( data ); + var b = this.readByte( data ); + + color.setRGB( r / 255, g / 255, b / 255 ); + + this.debugMessage( ' Color: ' + color.r + ', ' + color.g + ', ' + color.b ); + + } else if ( chunk.id === COLOR_F || chunk.id === LIN_COLOR_F ) { + + var r = this.readFloat( data ); + var g = this.readFloat( data ); + var b = this.readFloat( data ); + + color.setRGB( r, g, b ); + + this.debugMessage( ' Color: ' + color.r + ', ' + color.g + ', ' + color.b ); + + } else { + + this.debugMessage( ' Unknown color chunk: ' + chunk.toString( 16 ) ); + + } + + this.endChunk( chunk ); + return color; + + }, + + /** + * Read next chunk of data. + * + * @method readChunk + * @param {DataView} data Dataview. + * @return {Object} Chunk of data read. + */ + readChunk: function ( data ) { + + var chunk = {}; + + chunk.cur = this.position; + chunk.id = this.readWord( data ); + chunk.size = this.readDWord( data ); + chunk.end = chunk.cur + chunk.size; + chunk.cur += 6; + + return chunk; + + }, + + /** + * Set position to the end of the current chunk of data. + * + * @method endChunk + * @param {Object} chunk Data chunk. + */ + endChunk: function ( chunk ) { + + this.position = chunk.end; + + }, + + /** + * Move to the next data chunk. + * + * @method nextChunk + * @param {DataView} data Dataview. + * @param {Object} chunk Data chunk. + */ + nextChunk: function ( data, chunk ) { + + if ( chunk.cur >= chunk.end ) { + + return 0; + + } + + this.position = chunk.cur; + + try { + + var next = this.readChunk( data ); + chunk.cur += next.size; + return next.id; + + } catch ( e ) { + + this.debugMessage( 'Unable to read chunk at ' + this.position ); + return 0; + + } + + }, + + /** + * Reset dataview position. + * + * @method resetPosition + * @param {DataView} data Dataview. + */ + resetPosition: function () { + + this.position -= 6; + + }, + + /** + * Read byte value. + * + * @method readByte + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readByte: function ( data ) { + + var v = data.getUint8( this.position, true ); + this.position += 1; + return v; + + }, + + /** + * Read 32 bit float value. + * + * @method readFloat + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readFloat: function ( data ) { + + try { + + var v = data.getFloat32( this.position, true ); + this.position += 4; + return v; + + } catch ( e ) { + + this.debugMessage( e + ' ' + this.position + ' ' + data.byteLength ); + + } + + }, + + /** + * Read 32 bit signed integer value. + * + * @method readInt + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readInt: function ( data ) { + + var v = data.getInt32( this.position, true ); + this.position += 4; + return v; + + }, + + /** + * Read 16 bit signed integer value. + * + * @method readShort + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readShort: function ( data ) { + + var v = data.getInt16( this.position, true ); + this.position += 2; + return v; + + }, + + /** + * Read 64 bit unsigned integer value. + * + * @method readDWord + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readDWord: function ( data ) { + + var v = data.getUint32( this.position, true ); + this.position += 4; + return v; + + }, + + /** + * Read 32 bit unsigned integer value. + * + * @method readWord + * @param {DataView} data Dataview to read data from. + * @return {Number} Data read from the dataview. + */ + readWord: function ( data ) { + + var v = data.getUint16( this.position, true ); + this.position += 2; + return v; + + }, + + /** + * Read string value. + * + * @method readString + * @param {DataView} data Dataview to read data from. + * @param {Number} maxLength Max size of the string to be read. + * @return {String} Data read from the dataview. + */ + readString: function ( data, maxLength ) { + + var s = ''; + + for ( var i = 0; i < maxLength; i ++ ) { + + var c = this.readByte( data ); + if ( ! c ) { + + break; + + } + + s += String.fromCharCode( c ); + + } + + return s; + + }, + + /** + * Set resource path used to determine the file path to attached resources. + * + * @method setPath + * @param {String} path Path to resources. + * @return Self for chaining. + */ + setPath: function ( path ) { + + this.path = path; + + return this; + + }, + + /** + * Print debug message to the console. + * + * Is controlled by a flag to show or hide debug messages. + * + * @method debugMessage + * @param {Object} message Debug message to print to the console. + */ + debugMessage: function ( message ) { + + if ( this.debug ) { + + console.log( message ); + + } + + } +}; + +var NULL_CHUNK = 0x0000; +var M3DMAGIC = 0x4D4D; +var SMAGIC = 0x2D2D; +var LMAGIC = 0x2D3D; +var MLIBMAGIC = 0x3DAA; +var MATMAGIC = 0x3DFF; +var CMAGIC = 0xC23D; +var M3D_VERSION = 0x0002; +var M3D_KFVERSION = 0x0005; +var COLOR_F = 0x0010; +var COLOR_24 = 0x0011; +var LIN_COLOR_24 = 0x0012; +var LIN_COLOR_F = 0x0013; +var INT_PERCENTAGE = 0x0030; +var FLOAT_PERCENTAGE = 0x0031; +var MDATA = 0x3D3D; +var MESH_VERSION = 0x3D3E; +var MASTER_SCALE = 0x0100; +var LO_SHADOW_BIAS = 0x1400; +var HI_SHADOW_BIAS = 0x1410; +var SHADOW_MAP_SIZE = 0x1420; +var SHADOW_SAMPLES = 0x1430; +var SHADOW_RANGE = 0x1440; +var SHADOW_FILTER = 0x1450; +var RAY_BIAS = 0x1460; +var O_CONSTS = 0x1500; +var AMBIENT_LIGHT = 0x2100; +var BIT_MAP = 0x1100; +var SOLID_BGND = 0x1200; +var V_GRADIENT = 0x1300; +var USE_BIT_MAP = 0x1101; +var USE_SOLID_BGND = 0x1201; +var USE_V_GRADIENT = 0x1301; +var FOG = 0x2200; +var FOG_BGND = 0x2210; +var LAYER_FOG = 0x2302; +var DISTANCE_CUE = 0x2300; +var DCUE_BGND = 0x2310; +var USE_FOG = 0x2201; +var USE_LAYER_FOG = 0x2303; +var USE_DISTANCE_CUE = 0x2301; +var MAT_ENTRY = 0xAFFF; +var MAT_NAME = 0xA000; +var MAT_AMBIENT = 0xA010; +var MAT_DIFFUSE = 0xA020; +var MAT_SPECULAR = 0xA030; +var MAT_SHININESS = 0xA040; +var MAT_SHIN2PCT = 0xA041; +var MAT_TRANSPARENCY = 0xA050; +var MAT_XPFALL = 0xA052; +var MAT_USE_XPFALL = 0xA240; +var MAT_REFBLUR = 0xA053; +var MAT_SHADING = 0xA100; +var MAT_USE_REFBLUR = 0xA250; +var MAT_SELF_ILLUM = 0xA084; +var MAT_TWO_SIDE = 0xA081; +var MAT_DECAL = 0xA082; +var MAT_ADDITIVE = 0xA083; +var MAT_WIRE = 0xA085; +var MAT_FACEMAP = 0xA088; +var MAT_TRANSFALLOFF_IN = 0xA08A; +var MAT_PHONGSOFT = 0xA08C; +var MAT_WIREABS = 0xA08E; +var MAT_WIRE_SIZE = 0xA087; +var MAT_TEXMAP = 0xA200; +var MAT_SXP_TEXT_DATA = 0xA320; +var MAT_TEXMASK = 0xA33E; +var MAT_SXP_TEXTMASK_DATA = 0xA32A; +var MAT_TEX2MAP = 0xA33A; +var MAT_SXP_TEXT2_DATA = 0xA321; +var MAT_TEX2MASK = 0xA340; +var MAT_SXP_TEXT2MASK_DATA = 0xA32C; +var MAT_OPACMAP = 0xA210; +var MAT_SXP_OPAC_DATA = 0xA322; +var MAT_OPACMASK = 0xA342; +var MAT_SXP_OPACMASK_DATA = 0xA32E; +var MAT_BUMPMAP = 0xA230; +var MAT_SXP_BUMP_DATA = 0xA324; +var MAT_BUMPMASK = 0xA344; +var MAT_SXP_BUMPMASK_DATA = 0xA330; +var MAT_SPECMAP = 0xA204; +var MAT_SXP_SPEC_DATA = 0xA325; +var MAT_SPECMASK = 0xA348; +var MAT_SXP_SPECMASK_DATA = 0xA332; +var MAT_SHINMAP = 0xA33C; +var MAT_SXP_SHIN_DATA = 0xA326; +var MAT_SHINMASK = 0xA346; +var MAT_SXP_SHINMASK_DATA = 0xA334; +var MAT_SELFIMAP = 0xA33D; +var MAT_SXP_SELFI_DATA = 0xA328; +var MAT_SELFIMASK = 0xA34A; +var MAT_SXP_SELFIMASK_DATA = 0xA336; +var MAT_REFLMAP = 0xA220; +var MAT_REFLMASK = 0xA34C; +var MAT_SXP_REFLMASK_DATA = 0xA338; +var MAT_ACUBIC = 0xA310; +var MAT_MAPNAME = 0xA300; +var MAT_MAP_TILING = 0xA351; +var MAT_MAP_TEXBLUR = 0xA353; +var MAT_MAP_USCALE = 0xA354; +var MAT_MAP_VSCALE = 0xA356; +var MAT_MAP_UOFFSET = 0xA358; +var MAT_MAP_VOFFSET = 0xA35A; +var MAT_MAP_ANG = 0xA35C; +var MAT_MAP_COL1 = 0xA360; +var MAT_MAP_COL2 = 0xA362; +var MAT_MAP_RCOL = 0xA364; +var MAT_MAP_GCOL = 0xA366; +var MAT_MAP_BCOL = 0xA368; +var NAMED_OBJECT = 0x4000; +var N_DIRECT_LIGHT = 0x4600; +var DL_OFF = 0x4620; +var DL_OUTER_RANGE = 0x465A; +var DL_INNER_RANGE = 0x4659; +var DL_MULTIPLIER = 0x465B; +var DL_EXCLUDE = 0x4654; +var DL_ATTENUATE = 0x4625; +var DL_SPOTLIGHT = 0x4610; +var DL_SPOT_ROLL = 0x4656; +var DL_SHADOWED = 0x4630; +var DL_LOCAL_SHADOW2 = 0x4641; +var DL_SEE_CONE = 0x4650; +var DL_SPOT_RECTANGULAR = 0x4651; +var DL_SPOT_ASPECT = 0x4657; +var DL_SPOT_PROJECTOR = 0x4653; +var DL_SPOT_OVERSHOOT = 0x4652; +var DL_RAY_BIAS = 0x4658; +var DL_RAYSHAD = 0x4627; +var N_CAMERA = 0x4700; +var CAM_SEE_CONE = 0x4710; +var CAM_RANGES = 0x4720; +var OBJ_HIDDEN = 0x4010; +var OBJ_VIS_LOFTER = 0x4011; +var OBJ_DOESNT_CAST = 0x4012; +var OBJ_DONT_RECVSHADOW = 0x4017; +var OBJ_MATTE = 0x4013; +var OBJ_FAST = 0x4014; +var OBJ_PROCEDURAL = 0x4015; +var OBJ_FROZEN = 0x4016; +var N_TRI_OBJECT = 0x4100; +var POINT_ARRAY = 0x4110; +var POINT_FLAG_ARRAY = 0x4111; +var FACE_ARRAY = 0x4120; +var MSH_MAT_GROUP = 0x4130; +var SMOOTH_GROUP = 0x4150; +var MSH_BOXMAP = 0x4190; +var TEX_VERTS = 0x4140; +var MESH_MATRIX = 0x4160; +var MESH_COLOR = 0x4165; +var MESH_TEXTURE_INFO = 0x4170; +var KFDATA = 0xB000; +var KFHDR = 0xB00A; +var KFSEG = 0xB008; +var KFCURTIME = 0xB009; +var AMBIENT_NODE_TAG = 0xB001; +var OBJECT_NODE_TAG = 0xB002; +var CAMERA_NODE_TAG = 0xB003; +var TARGET_NODE_TAG = 0xB004; +var LIGHT_NODE_TAG = 0xB005; +var L_TARGET_NODE_TAG = 0xB006; +var SPOTLIGHT_NODE_TAG = 0xB007; +var NODE_ID = 0xB030; +var NODE_HDR = 0xB010; +var PIVOT = 0xB013; +var INSTANCE_NAME = 0xB011; +var MORPH_SMOOTH = 0xB015; +var BOUNDBOX = 0xB014; +var POS_TRACK_TAG = 0xB020; +var COL_TRACK_TAG = 0xB025; +var ROT_TRACK_TAG = 0xB021; +var SCL_TRACK_TAG = 0xB022; +var MORPH_TRACK_TAG = 0xB026; +var FOV_TRACK_TAG = 0xB023; +var ROLL_TRACK_TAG = 0xB024; +var HOT_TRACK_TAG = 0xB027; +var FALL_TRACK_TAG = 0xB028; +var HIDE_TRACK_TAG = 0xB029; +var POLY_2D = 0x5000; +var SHAPE_OK = 0x5010; +var SHAPE_NOT_OK = 0x5011; +var SHAPE_HOOK = 0x5020; +var PATH_3D = 0x6000; +var PATH_MATRIX = 0x6005; +var SHAPE_2D = 0x6010; +var M_SCALE = 0x6020; +var M_TWIST = 0x6030; +var M_TEETER = 0x6040; +var M_FIT = 0x6050; +var M_BEVEL = 0x6060; +var XZ_CURVE = 0x6070; +var YZ_CURVE = 0x6080; +var INTERPCT = 0x6090; +var DEFORM_LIMIT = 0x60A0; +var USE_CONTOUR = 0x6100; +var USE_TWEEN = 0x6110; +var USE_SCALE = 0x6120; +var USE_TWIST = 0x6130; +var USE_TEETER = 0x6140; +var USE_FIT = 0x6150; +var USE_BEVEL = 0x6160; +var DEFAULT_VIEW = 0x3000; +var VIEW_TOP = 0x3010; +var VIEW_BOTTOM = 0x3020; +var VIEW_LEFT = 0x3030; +var VIEW_RIGHT = 0x3040; +var VIEW_FRONT = 0x3050; +var VIEW_BACK = 0x3060; +var VIEW_USER = 0x3070; +var VIEW_CAMERA = 0x3080; +var VIEW_WINDOW = 0x3090; +var VIEWPORT_LAYOUT_OLD = 0x7000; +var VIEWPORT_DATA_OLD = 0x7010; +var VIEWPORT_LAYOUT = 0x7001; +var VIEWPORT_DATA = 0x7011; +var VIEWPORT_DATA_3 = 0x7012; +var VIEWPORT_SIZE = 0x7020; +var NETWORK_VIEW = 0x7030; + +export default THREE.TDSLoader; diff --git a/seminar06-planning/simulator/js/physics/Car.js b/seminar06-planning/simulator/js/physics/Car.js new file mode 100644 index 0000000..9a50417 --- /dev/null +++ b/seminar06-planning/simulator/js/physics/Car.js @@ -0,0 +1,122 @@ +export default class Car { + constructor(x = 0, y = 0, rotation = 0) { + this.setPose(x, y, rotation); + } + + static getFrontAxlePosition(pos, rot) { + return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.WHEEL_BASE).add(pos); + } + + static getFakeAxlePosition(pos, rot) { + return Car.frontToRearAxlePosition(pos, rot); + } + + static centerToRearAxlePosition(pos, rot) { + return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.REAR_AXLE_POS).add(pos); + } + + static frontToRearAxlePosition(pos, rot) { + return THREE.Vector2.fromAngle(rot).multiplyScalar(-Car.WHEEL_BASE).add(pos); + } + + get pose() { + return { pos: this.rearAxlePosition.clone(), rot: this.rotation, velocity: this.velocity, curv: this.curvature, dCurv: this.dCurv, ddCurv: this.ddCurv }; + } + + get curvature() { + return Math.tan(this.wheelAngle) / Car.WHEEL_BASE; + } + + get rearAxlePosition() { + const { x, y } = this.position; + const rot = this.rotation; + return new THREE.Vector2(x + Math.cos(rot) * Car.REAR_AXLE_POS, y + Math.sin(rot) * Car.REAR_AXLE_POS); + } + + get frontAxlePosition() { + const { x, y } = this.position; + const rot = this.rotation; + return new THREE.Vector2(x + Math.cos(rot) * Car.FRONT_AXLE_POS, y + Math.sin(rot) * Car.FRONT_AXLE_POS); + } + + setPose(x, y, rotation) { + // Translate so that x and y become the center of the vehicle (instead of the center of the rear axle) + x -= Car.REAR_AXLE_POS * Math.cos(rotation); + y -= Car.REAR_AXLE_POS * Math.sin(rotation); + + this.position = new THREE.Vector2(x, y); + this.rotation = Math.wrapAngle(rotation); + this.velocity = 0; + this.acceleration = 0; + this.wheelAngle = 0; + this.wheelAngularVelocity = 0; + this.dCurv = 0; // derivative with respect to arc length + this.ddCurv = 0; // derivative with respect to arc length + } + + step(dt) { + const curvPrev = this.curvature; + const dCurvPrev = this.dCurv; + + const drag = (0.5 * Car.DRAG_COEFF * Car.FRONTAL_AREA * Car.DENSITY_OF_AIR * Math.abs(this.velocity) + Car.ROLL_RESIST) * -this.velocity; + this.velocity += (this.acceleration + drag / Car.MASS) * dt; + + const velocitySq = this.velocity * this.velocity; + const maxWheelAngle = Math.clamp(Math.atan(Car.MAX_LATERAL_ACCEL * Car.WHEEL_BASE / velocitySq), 0.07, Car.MAX_WHEEL_ANGLE); + this.wheelAngle = Math.clamp(Math.wrapAngle(this.wheelAngle + this.wheelAngularVelocity * dt), -maxWheelAngle, maxWheelAngle); + + const angularVelocity = this.velocity * this.curvature; + this.rotation = Math.wrapAngle(this.rotation + angularVelocity * dt); + + const dist = this.velocity * dt; + this.position = THREE.Vector2.fromAngle(this.rotation).multiplyScalar(dist).add(this.position); + + this.dCurv = dist > 0.1 ? (this.curvature - curvPrev) / dist : 0; + this.ddCurv = dist > 0.1 ? (this.dCurv - dCurvPrev) / dist : 0; + } + + update(controls, dt) { + const gas = Math.clamp(controls.gas, -1, +1); + const brake = Math.clamp(controls.brake, 0, 1); + const steer = Math.clamp(controls.steer, -1, +1); + + if (brake > 0) { + this.acceleration = -Math.sign(this.velocity) * Car.MAX_BRAKE_DECEL * brake; + const newVelocity = this.velocity + this.acceleration * dt; + + // If applying the braking deceleration at the next step would cause the velocity + // to change directions, then just set the car as stopped. + if (Math.sign(newVelocity) != Math.sign(this.velocity)) { + this.velocity = 0; + this.acceleration = 0; + } + } else { + this.acceleration = Car.MAX_GAS_ACCEL * gas; + } + + if (steer != 0) { + this.wheelAngularVelocity = steer * Car.MAX_STEER_SPEED; + } else { + this.wheelAngularVelocity = Math.clamp(-this.wheelAngle / Car.MAX_WHEEL_ANGLE * this.velocity * this.velocity * dt, -Car.MAX_STEER_SPEED, Car.MAX_STEER_SPEED); + } + } +} + +Car.HALF_CAR_LENGTH = 2.5; // meters +Car.HALF_CAR_WIDTH = 1; // meters +Car.HALF_WHEEL_LENGTH = 0.38; // meters +Car.HALF_WHEEL_WIDTH = 0.12; // meters +Car.MAX_WHEEL_ANGLE = 32 / 180 * Math.PI; // radians +Car.MASS = 1600; // kg +Car.DRAG_COEFF = 0.7; +Car.DENSITY_OF_AIR = 1.8580608; // (kg/m^3) +Car.FRONTAL_AREA = 1.85; // m^2 +Car.ROLL_RESIST = 0; +Car.MAX_STEER_SPEED = 0.8;//1.2; // Radians per second +Car.MAX_GAS_ACCEL = 3.0; // m / s^2 +Car.MAX_BRAKE_DECEL = 3.0; // m / s^2 +Car.WHEEL_LATERAL_POS = 0.843; // meters +Car.FRONT_AXLE_POS = 1.6; // meters +Car.REAR_AXLE_POS = -1.43; // meters +Car.WHEEL_BASE = Car.FRONT_AXLE_POS - Car.REAR_AXLE_POS; // meters +Car.MAX_LATERAL_ACCEL = 5.81; // m / s^2 diff --git a/seminar06-planning/simulator/js/physics/Physics.js b/seminar06-planning/simulator/js/physics/Physics.js new file mode 100644 index 0000000..7370a9a --- /dev/null +++ b/seminar06-planning/simulator/js/physics/Physics.js @@ -0,0 +1,18 @@ +import Car from "./Car.js"; + +export default class Physics { + constructor() { + this.cars = []; + } + + step(dt) { + this.cars.forEach(c => c.step(dt)); + } + + createCar() { + const newCar = new Car(); + this.cars.push(newCar); + + return newCar; + } +}; diff --git a/seminar06-planning/simulator/js/simulator/Dashboard.js b/seminar06-planning/simulator/js/simulator/Dashboard.js new file mode 100644 index 0000000..011909a --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/Dashboard.js @@ -0,0 +1,132 @@ +import Car from "../physics/Car.js"; + +const MPS_TO_MPH = 2.23694; +const METERS_TO_FEET = 3.28084; + +export default class Dashboard { + constructor(car) { + this.car = car; + this.units = 'metric'; + + if (document.readyState == 'complete') { + this.fetchDomElements.call(this); + } else { + document.addEventListener('readystatechange', event => { + if (event.target.readyState == 'complete') + this.fetchDomElements.call(this); + }); + } + } + + fetchDomElements() { + this.wheelDom = document.getElementById('wheel'); + this.wheelPieDom = document.getElementById('wheel-pie'); + this.wheelPieLeftDom = document.getElementById('wheel-pie-left'); + this.wheelPieRightDom = document.getElementById('wheel-pie-right'); + this.gearDom = document.getElementById('gear'); + this.gasDom = document.getElementById('gas'); + this.brakeDom = document.getElementById('brake'); + this.speedDom = document.getElementById('speed'); + this.stationDom = document.getElementById('station'); + this.latitudeDom = document.getElementById('latitude'); + this.planTimeDom = document.getElementById('plan-time'); + this.elapsedTimeDom = document.getElementById('elapsed-time'); + + this.speedUnitsDom = document.getElementById('speed-units'); + this.stationUnitsDom = document.getElementById('station-units'); + this.latitudeUnitsDom = document.getElementById('latitude-units'); + + [this.speedUnitsDom, this.stationUnitsDom, this.latitudeUnitsDom].forEach(el => { + el.addEventListener('click', event => { + this.toggleUnits(); + }); + }); + } + + toggleUnits() { + let speedUnits; + let distanceUnits; + + if (this.units == 'metric') { + this.units = 'imperial'; + speedUnits = 'mph'; + distanceUnits = 'feet'; + } else { + this.units = 'metric'; + speedUnits = 'm/s'; + distanceUnits = 'meters'; + } + + this.speedUnitsDom.textContent = speedUnits; + this.stationUnitsDom.textContent = distanceUnits; + this.latitudeUnitsDom.textContent = distanceUnits; + } + + updatePlanTime(planTime) { + if (!this.wheelDom) return; + + this.planTimeDom.textContent = planTime !== null ? (planTime).toLocaleString(undefined, { maximumFractionDigits: 3 }) : '—'; + } + + update(controls, speed, station, latitude, elapsedTime, planTime) { + if (!this.wheelDom) return; + + const wheelTurn = Math.clamp(this.car.wheelAngle / Car.MAX_WHEEL_ANGLE * 0.95, -1, +1); + + this.wheelDom.style.transform = `rotate(${wheelTurn}turn)`; + + if (wheelTurn >= 0) { + this.wheelPieRightDom.style.transform = `rotate(${wheelTurn}turn)`; + + if (wheelTurn <= 0.5) { + this.wheelPieDom.style.clipPath = "inset(0 0 0 50%)"; + this.wheelPieLeftDom.style.transform = "rotate(0)"; + } else { + this.wheelPieDom.style.clipPath = "inset(0 0 0 0)"; + this.wheelPieLeftDom.style.transform = "rotate(0.5turn)"; + } + } else { + this.wheelPieRightDom.style.transform = `rotate(${0.5 + wheelTurn}turn)`; + + if (wheelTurn >= -0.5) { + this.wheelPieDom.style.clipPath = "inset(0 50% 0 0)"; + this.wheelPieLeftDom.style.transform = "rotate(0.5turn)"; + } else { + this.wheelPieDom.style.clipPath = "inset(0 0 0 0)"; + this.wheelPieLeftDom.style.transform = "rotate(0)"; + } + } + + this.gearDom.innerText = controls.gas < 0 ? 'R' : 'D'; + this.brakeDom.style.clipPath = `inset(50% 50% 0 ${50 - controls.brake * 25}%)`; + this.gasDom.style.clipPath = `inset(50% ${50 - Math.abs(controls.gas) * 25}% 0 50%)`; + + if (this.units == 'imperial') { + speed *= MPS_TO_MPH; + station = station !== null ? station * METERS_TO_FEET : null; + latitude = latitude !== null ? latitude * METERS_TO_FEET : null; + } + + let latitudeText = latitude !== null ? latitude.toFixed(2) : '—'; + if (latitudeText == '-0.00') latitudeText = '0.00'; + + this.speedDom.textContent = speed.toFixed(1); + this.stationDom.textContent = station !== null ? station.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 }) : '—'; + this.latitudeDom.textContent = latitudeText; + this.updatePlanTime(planTime); + + let mins = Math.floor(elapsedTime / 60); + let seconds = elapsedTime % 60; + + if (mins == 0) { + this.elapsedTimeDom.textContent = seconds.toFixed(1); + } else { + if (seconds < 10) + seconds = '0' + seconds.toFixed(1); + else + seconds = seconds.toFixed(1); + + this.elapsedTimeDom.textContent = `${mins}:${seconds}`; + } + } +} diff --git a/seminar06-planning/simulator/js/simulator/DynamicObstacleEditor.js b/seminar06-planning/simulator/js/simulator/DynamicObstacleEditor.js new file mode 100644 index 0000000..bff5059 --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/DynamicObstacleEditor.js @@ -0,0 +1,185 @@ +import DynamicObstacle from "../autonomy/DynamicObstacle.js"; +import PathPlannerConfigEditor from "./PathPlannerConfigEditor.js"; + +export default class DynamicObstacleEditor { + constructor() { + this.editorDom = document.getElementById('editor-dynamic-obstacles-box'); + this.formsContainer = document.getElementById('editor-dynamic-obstacle-forms'); + this.statsDynamicObstacles = document.getElementById('editor-stats-dynamic-obstacles'); + + document.getElementById('editor-add-dynamic-obstacle').addEventListener('click', this.addDynamicObstacle.bind(this)); + } + + enable() { + this.editorDom.classList.remove('is-hidden'); + } + + disable() { + this.editorDom.classList.add('is-hidden'); + } + + toJSON() { + const forms = this.formsContainer.getElementsByTagName('form'); + const obstacles = []; + + for (let i = 0; i < forms.length; i++) { + const formData = new FormData(forms[i]); + const params = { parallel: false }; + + for (const [k, v] of formData.entries()) + params[k] = v; + + let type = 0; + if (params.type == 'cyclist') + type = 1; + else if (params.type == 'pedestrian') + type = 2; + + obstacles.push({ + p: [params.sPos, params.lPos], + v: [params.sVel, params.lVel], + l: !!params.parallel ? 1 : 0, + t: type + }); + } + + return obstacles; + } + + loadJSON(json) { + this.clearDynamicObstacles(); + + json.forEach(o => { + const form = this.addDynamicObstacle(); + + form['sPos'].value = o.p[0]; + form['lPos'].value = o.p[1]; + form['sVel'].value = o.v[0]; + form['lVel'].value = o.v[1]; + form['parallel'].checked = !!o.l; + form['type'].selectedIndex = o.t; + }); + } + + collectDynamicObstacles() { + const forms = this.formsContainer.getElementsByTagName('form'); + const obstacles = []; + + for (let i = 0; i < forms.length; i++) { + const formData = new FormData(forms[i]); + const params = { parallel: false }; + + for (const [k, v] of formData.entries()) + params[k] = v; + + const pos = new THREE.Vector2(Number(params.sPos) || 0, (Number(params.lPos) || 0) * PathPlannerConfigEditor.internalConfig.roadWidth / 2); + const vel = new THREE.Vector2(Number(params.sVel) || 0, Number(params.lVel) || 0); + const parallel = !!params.parallel; + + obstacles.push(new DynamicObstacle(params.type, pos, vel, parallel)); + } + + return obstacles; + } + + addDynamicObstacle() { + const index = this.formsContainer.getElementsByTagName('form').length + 1; + const form = this.buildForm(index); + + this.formsContainer.appendChild(form); + this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName('form').length; + + return form; + } + + removeDynamicObstacle(form) { + this.formsContainer.removeChild(form); + this.reindexForms(); + this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName('form').length; + } + + clearDynamicObstacles() { + this.formsContainer.innerHTML = ''; + this.statsDynamicObstacles.textContent = 0; + } + + reindexForms() { + const forms = this.formsContainer.getElementsByTagName('form'); + + for (let i = 0; i < forms.length; i++) { + forms[i].getElementsByClassName('dynamic-obstacle-index')[0].textContent = i + 1; + } + } + + buildForm(index) { + const html = + `
+
+
+
+
${index}
+
+
+
+
+
+
+ +
+
+
+
+
+
+
+ +
+
+
+
+
+
+ +
+
+ +
+
+
+
+
+
+ +
+
+ +
+
+
+
+
+
+ + + +
+
+
+
+
`; + + const template = document.createElement('template'); + template.innerHTML = html; + const form = template.content.firstChild; + + form.getElementsByClassName('editor-remove-dynamic-obstacle')[0].addEventListener('click', e => this.removeDynamicObstacle(form)); + + return form; + } +} diff --git a/seminar06-planning/simulator/js/simulator/Editor.js b/seminar06-planning/simulator/js/simulator/Editor.js new file mode 100644 index 0000000..586992b --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/Editor.js @@ -0,0 +1,672 @@ +import LanePath from "../autonomy/LanePath.js"; +import StaticObstacle from "../autonomy/StaticObstacle.js"; +import DynamicObstacleEditor from "./DynamicObstacleEditor.js"; +import ScenarioManager from "./ScenarioManager.js"; +import ShareManager from "./ShareManager.js"; +import { formatDate } from "../Helpers.js"; + +const GROUND_PLANE = new THREE.Plane(new THREE.Vector3(0, 1, 0)); + +const NORMAL_OPACITY = 0.7; +const HOVER_OPACITY = 1; +const NORMAL_POINT_COLOR = 0x0088ff; +const HOVER_POINT_COLOR = 0x33ccff; +const NORMAL_STATIC_OBSTACLE_COLOR = 0xdd0000; +const HOVER_STATIC_OBSTACLE_COLOR = 0xdd3333; +const NORMAL_DYNAMIC_OBSTACLE_COLOR = 0xff8800; +const HOVER_DYNAMIC_OBSTACLE_COLOR = 0xffcc33; + +const INITIAL_SPEED_FALLBACK = 20; +const SPEED_LIMIT_FALLBACK = 20; +const LANE_PREFERENCE_FALLBACK = +1; + +export default class Editor { + constructor(canvas, camera, scene) { + this.canvas = canvas; + this.camera = camera; + + this.isEnabled = false; + this.raycaster = new THREE.Raycaster(); + this.mouse = new THREE.Vector2(); + this.dragOffset = new THREE.Vector3(); + this.draggingPoint = null; + this.pointIndex = 0; + this.obstacleIndex = 0; + this.previousSavedName = null; + this.scenarioManager = new ScenarioManager(this); + this.shareManager = new ShareManager(); + + this.centerlineGeometry = new THREE.Geometry(); + this.leftBoundaryGeometry = new THREE.Geometry(); + this.rightBoundaryGeometry = new THREE.Geometry(); + this.draggingObstaclePreview = null; + + this.group = new THREE.Group(); + this.group.renderOrder = 1; + this.pointGroup = new THREE.Group(); + this.pointGroup.renderOrder = 2; + this.obstacleGroup = new THREE.Group(); + this.obstacleGroup.renderOrder = 1; + this.group.add(this.obstacleGroup); + this.group.add(this.pointGroup); + scene.add(this.group); + + this.lanePath = new LanePath(); + this.dynamicObstacleEditor = new DynamicObstacleEditor(); + + this.editorPathButton = document.getElementById('editor-path'); + this.editorPathButton.addEventListener('click', e => this.changeEditMode('path')); + this.editorObstaclesButton = document.getElementById('editor-obstacles'); + this.editorObstaclesButton.addEventListener('click', e => this.changeEditMode('staticObstacles')); + this.editorDynamicObstaclesButton = document.getElementById('editor-dynamic-obstacles'); + this.editorDynamicObstaclesButton.addEventListener('click', e => this.changeEditMode('dynamicObstacles')); + + this.editorRoadBox = document.getElementById('editor-road-box'); + this.initialSpeedDom = document.getElementById('editor-initial-speed'); + this.speedLimitDom = document.getElementById('editor-speed-limit'); + this.laneLeftDom = document.getElementById('editor-lane-left'); + this.laneRightDom = document.getElementById('editor-lane-right'); + + this.laneLeftDom.addEventListener('click', e => this._changeLanePreference(-1)); + this.laneRightDom.addEventListener('click', e => this._changeLanePreference(+1)); + + this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK; + this.speedLimitDom.value = SPEED_LIMIT_FALLBACK; + this._changeLanePreference(LANE_PREFERENCE_FALLBACK); + + this.statsRoadLength = document.getElementById('editor-stats-road-length'); + this.statsStaticObstacles = document.getElementById('editor-stats-static-obstacles'); + this.statsStation = document.getElementById('editor-stats-station'); + this.statsLatitude = document.getElementById('editor-stats-latitude'); + this.scenarioNameDom = document.getElementById('editor-scenario-name'); + this.scenarioSavedAtDom = document.getElementById('editor-scenario-saved-at'); + + this.helpPath = document.getElementById('editor-help-path'); + this.helpStaticObstacles = document.getElementById('editor-help-static-obstacles'); + this.helpDynamicObstacles = document.getElementById('editor-help-dynamic-obstacles'); + + this.changeEditMode('path'); + this.removeMode = false; + + canvas.addEventListener('mousedown', this.mouseDown.bind(this)); + canvas.addEventListener('mousemove', this.mouseMove.bind(this)); + canvas.addEventListener('mouseup', this.mouseUp.bind(this)); + canvas.addEventListener('contextmenu', e => this.isEnabled && e.preventDefault()); + + const editorClearOptions = document.getElementById('editor-clear-options'); + document.getElementById('editor-clear').addEventListener('click', event => { + event.stopPropagation(); + editorClearOptions.classList.toggle('is-hidden'); + }); + document.addEventListener('click', () => editorClearOptions.classList.add('is-hidden')); + + document.getElementById('editor-clear-obstacles').addEventListener('click', this.clearStaticObstacles.bind(this)); + document.getElementById('editor-clear-dynamic-obstacles').addEventListener('click', this.dynamicObstacleEditor.clearDynamicObstacles.bind(this.dynamicObstacleEditor)); + document.getElementById('editor-clear-path').addEventListener('click', this.clearPath.bind(this)); + document.getElementById('editor-clear-all').addEventListener('click', this.clearAll.bind(this)); + + document.getElementById('editor-save').addEventListener('click', this.saveClicked.bind(this)); + document.getElementById('editor-load').addEventListener('click', this.loadClicked.bind(this)); + document.getElementById('editor-share').addEventListener('click', this.shareClicked.bind(this)); + + document.addEventListener('keydown', this.keyDown.bind(this)); + document.addEventListener('keyup', this.keyUp.bind(this)); + + const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight); + this.centerlineObject = new THREE.Mesh( + new THREE.Geometry(), + new MeshLineMaterial({ + color: new THREE.Color(0x004488), + lineWidth: 8, + resolution: resolution, + sizeAttenuation: false, + near: camera.near, + far: camera.far, + depthWrite: false + }) + ); + this.centerlineObject.rotation.x = Math.PI / 2; + this.centerlineObject.renderOrder = 1; + this.group.add(this.centerlineObject); + + this.leftBoundaryObject = new THREE.Mesh( + new THREE.Geometry(), + new MeshLineMaterial({ + color: new THREE.Color(0xff40ff), + lineWidth: 0.15, + resolution: resolution, + transparent: true, + opacity: 0.7 + }) + ); + this.leftBoundaryObject.rotation.x = Math.PI / 2; + this.leftBoundaryObject.renderOrder = 1; + this.group.add(this.leftBoundaryObject); + + this.rightBoundaryObject = new THREE.Mesh( + new THREE.Geometry(), + new MeshLineMaterial({ + color: new THREE.Color(0xff40ff), + lineWidth: 0.15, + resolution: resolution, + transparent: true, + opacity: 0.7 + }) + ); + this.rightBoundaryObject.rotation.x = Math.PI / 2; + this.rightBoundaryObject.renderOrder = 1; + this.group.add(this.rightBoundaryObject); + + window.addEventListener('resize', () => { + // Use setTimeout to queue the resolution update after the canvas is reflowed. + // This gets around some weirdness noticed when opening and closing Chrome Developer Tools. + setTimeout(() => { + const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight); + this.centerlineObject.material.uniforms.resolution.value = resolution; + this.leftBoundaryObject.material.uniforms.resolution.value = resolution; + this.rightBoundaryObject.material.uniforms.resolution.value = resolution; + }, 0); + }); + } + + get enabled() { + return this.isEnabled; + } + + set enabled(e) { + this.isEnabled = e; + this.pointGroup.visible = this.obstacleGroup.visible = !!this.isEnabled + } + + get staticObstacles() { + 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)); + } + + get dynamicObstacles() { + return this.dynamicObstacleEditor.collectDynamicObstacles(); + } + + get initialSpeed() { + let speed = parseFloat(this.initialSpeedDom.value); + if (Number.isNaN(speed) || speed < 0) + speed = 0; + + return Number.isNaN(speed) || speed < 0 ? INITIAL_SPEED_FALLBACK : speed; + } + + get speedLimit() { + let limit = parseFloat(this.speedLimitDom.value); + if (Number.isNaN(limit) || limit < 0) + limit = 0; + + return Number.isNaN(limit) || limit < 0 ? SPEED_LIMIT_FALLBACK : limit; + } + + scenarioToJSON() { + const trunc = n => +n.toFixed(5); + + const json = { + p: Array.prototype.concat.apply([], this.lanePath.anchors.map(a => [trunc(a.x), trunc(a.y)])), + s: this.staticObstacles.map(o => o.toJSON()), + d: this.dynamicObstacleEditor.toJSON(), + l: Number(this.lanePath.arcLength.toFixed(3)), + c: { + s: this.initialSpeedDom.value, + sl: this.speedLimitDom.value, + lp: this.lanePreference + }, + v: 1 + }; + + return json; + } + + loadJSON(json) { + if (json.p === undefined || json.p.length % 2 != 0) { + throw new Error('Incomplete lane path.'); + } + + this.clearAll(); + + this.lanePath = new LanePath(); + for (let i = 0; i < json.p.length; i += 2) { + this.addPoint(new THREE.Vector2(json.p[i], json.p[i + 1]), false); + } + this.lanePath.resampleAll(); + this.rebuildPathGeometry(); + + json.s.forEach(o => { + const staticObstacle = StaticObstacle.fromJSON(o); + this.addStaticObstacle(new THREE.Vector3(staticObstacle.pos.x, 0, staticObstacle.pos.y), staticObstacle.width, staticObstacle.height, staticObstacle.rot) + }); + + this.dynamicObstacleEditor.loadJSON(json.d); + + let initialSpeed = INITIAL_SPEED_FALLBACK; + let speedLimit = SPEED_LIMIT_FALLBACK; + try { initialSpeed = json.c.s; } catch (e) { } + try { speedLimit = json.c.sl; } catch (e) { } + + this.initialSpeedDom.value = initialSpeed; + this.speedLimitDom.value = speedLimit; + + let lanePreference = LANE_PREFERENCE_FALLBACK; + try { + if (typeof(json.c.lp) === 'number') + lanePreference = Math.sign(json.c.lp) || LANE_PREFERENCE_FALLBACK; + } catch (e) { } + + this._changeLanePreference(lanePreference); + } + + update() { + if (!this.isEnabled) return; + + this.raycaster.setFromCamera(this.mouse, this.camera); + const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE); + + const [station, latitude, _around] = this.lanePath.stationLatitudeFromPosition(new THREE.Vector2(intersection.x, intersection.z)); + this.statsStation.textContent = (station || 0).toFixed(1); + this.statsLatitude.textContent = (latitude || 0).toFixed(1); + + if (this.draggingPoint) { + if (intersection != null) { + this.updatePoint(this.draggingPoint, intersection.clone().add(this.dragOffset)); + this.rebuildPathGeometry(); + } + } else if (this.draggingObstacle) { + if (intersection !== null) { + if (this.draggingObstacle === true) { + if (this.draggingObstaclePreview) this.group.remove(this.draggingObstaclePreview); + + const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection); + + this.draggingObstaclePreview = new THREE.Mesh( + new THREE.PlaneGeometry(width, height), + new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: 0.4 }) + ); + this.draggingObstaclePreview.rotation.x = -Math.PI / 2; + this.draggingObstaclePreview.position.copy(center); + this.group.add(this.draggingObstaclePreview); + } else { + this.draggingObstacle.position.copy(intersection.clone().add(this.dragOffset)); + } + } + } else if (this.rotatingObstacle) { + const rotation = (this.dragOffset.x - this.mouse.x) * 2 * Math.PI; + this.rotatingObstacle.rotation.z = Math.wrapAngle(rotation + this.initialObstacleRotation); + } else { + this.pointGroup.children.forEach(p => { + p.material.color.set(NORMAL_POINT_COLOR) + p.material.opacity = NORMAL_OPACITY; + }); + + this.obstacleGroup.children.forEach(o => { + o.material.color.set(NORMAL_STATIC_OBSTACLE_COLOR) + o.material.opacity = NORMAL_OPACITY; + }); + + this.canvas.classList.remove('editor-grab', 'editor-grabbing', 'editor-removing'); + + if (this.editMode == 'path' && this.pointGroup.children.length > 0) { + let picked = null; + this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => { + if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p; + }); + + if (picked) { + picked.object.material.color.set(HOVER_POINT_COLOR); + picked.object.material.opacity = HOVER_OPACITY; + + if (this.removeMode) + this.canvas.classList.add('editor-removing'); + else + this.canvas.classList.add('editor-grab'); + } + } else if (this.editMode == 'staticObstacles' && this.obstacleGroup.children.length > 0) { + let picked = null; + this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => { + if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o; + }); + + if (picked) { + picked.object.material.color.set(HOVER_STATIC_OBSTACLE_COLOR); + picked.object.material.opacity = HOVER_OPACITY; + + if (this.removeMode) + this.canvas.classList.add('editor-removing'); + else + this.canvas.classList.add('editor-grab'); + } + } + } + } + + changeEditMode(mode) { + this.editorPathButton.classList.add('is-outlined'); + this.editorObstaclesButton.classList.add('is-outlined'); + this.editorDynamicObstaclesButton.classList.add('is-outlined'); + this.editorPathButton.classList.remove('is-selected'); + this.editorObstaclesButton.classList.remove('is-selected'); + this.editorDynamicObstaclesButton.classList.remove('is-selected'); + this.editorRoadBox.classList.add('is-hidden'); + this.helpPath.classList.add('is-hidden'); + this.helpStaticObstacles.classList.add('is-hidden'); + this.helpDynamicObstacles.classList.add('is-hidden'); + + if (mode == 'path') { + this.editMode = 'path'; + this.editorPathButton.classList.remove('is-outlined'); + this.editorPathButton.classList.add('is-selected'); + this.editorRoadBox.classList.remove('is-hidden'); + this.helpPath.classList.remove('is-hidden'); + this.dynamicObstacleEditor.disable(); + } else if (mode == 'staticObstacles') { + this.editMode = 'staticObstacles'; + this.editorObstaclesButton.classList.remove('is-outlined'); + this.editorObstaclesButton.classList.add('is-selected'); + this.helpStaticObstacles.classList.remove('is-hidden'); + this.dynamicObstacleEditor.disable(); + } else { + this.editMode = 'dynamicObstacles'; + this.editorDynamicObstaclesButton.classList.remove('is-outlined'); + this.editorDynamicObstaclesButton.classList.add('is-selected'); + this.helpDynamicObstacles.classList.remove('is-hidden'); + this.dynamicObstacleEditor.enable(); + } + } + + addStaticObstacle(center, width, height, rotation = 0) { + const obstacle = new THREE.Mesh( + new THREE.PlaneGeometry(width, height), + new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: NORMAL_OPACITY }) + ); + obstacle.rotation.x = -Math.PI / 2; + obstacle.rotation.z = -Math.wrapAngle(rotation); + obstacle.position.copy(center); + obstacle.userData = { index: this.obstacleIndex++, width: width, height: height }; + + this.obstacleGroup.add(obstacle); + this.statsStaticObstacles.textContent = this.obstacleGroup.children.length; + } + + removeStaticObstacle(obstacle) { + this.obstacleGroup.remove(obstacle); + this.statsStaticObstacles.textContent = this.obstacleGroup.children.length; + } + + clearStaticObstacles() { + this.group.remove(this.obstacleGroup); + this.obstacleGroup = new THREE.Group(); + this.obstacleGroup.renderOrder = 1; + this.group.add(this.obstacleGroup); + this.obstacleIndex = 0; + this.statsStaticObstacles.textContent = 0; + } + + clearAll() { + this.clearPath(); + this.clearStaticObstacles(); + this.dynamicObstacleEditor.clearDynamicObstacles(); + } + + rebuildPathGeometry() { + if (this.lanePath.anchors.length > 1) { + this.centerlineGeometry.setFromPoints(this.lanePath.centerline); + const centerline = new MeshLine(); + centerline.setGeometry(this.centerlineGeometry); + this.centerlineObject.geometry = centerline.geometry; + + this.leftBoundaryGeometry.setFromPoints(this.lanePath.leftBoundary); + const leftBoundary = new MeshLine(); + leftBoundary.setGeometry(this.leftBoundaryGeometry); + this.leftBoundaryObject.geometry = leftBoundary.geometry; + + this.rightBoundaryGeometry.setFromPoints(this.lanePath.rightBoundary); + const rightBoundary = new MeshLine(); + rightBoundary.setGeometry(this.rightBoundaryGeometry); + this.rightBoundaryObject.geometry = rightBoundary.geometry; + } else { + this.centerlineObject.geometry.dispose(); + this.centerlineObject.geometry = new THREE.Geometry(); + + this.leftBoundaryObject.geometry.dispose(); + this.leftBoundaryObject.geometry = new THREE.Geometry(); + + this.rightBoundaryObject.geometry.dispose(); + this.rightBoundaryObject.geometry = new THREE.Geometry(); + } + + this.statsRoadLength.textContent = this.lanePath.arcLength.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 }); + } + + addPoint(pos, resample = true) { + const point = new THREE.Mesh( + new THREE.CircleGeometry(1, 32), + new THREE.MeshBasicMaterial({ + color: NORMAL_POINT_COLOR, + depthTest: false, + transparent: true, + opacity: NORMAL_OPACITY + }) + ); + point.rotation.x = -Math.PI / 2; + point.position.set(pos.x, 0, pos.y); + point.userData = { index: this.pointIndex++ }; + + this.lanePath.addAnchor(pos, resample); + this.pointGroup.add(point); + + return point; + } + + updatePoint(object, pos) { + object.position.copy(pos); + this.lanePath.updateAnchor(object.userData.index, new THREE.Vector2(pos.x, pos.z)); + } + + removePoint(object) { + const index = object.userData.index; + + this.pointGroup.remove(object); + this.pointGroup.children.forEach(p => { + if (p.userData.index > index) p.userData.index--; + }); + this.pointIndex--; + + this.lanePath.removeAnchor(index); + } + + clearPath() { + this.group.remove(this.pointGroup); + this.pointGroup = new THREE.Group(); + this.pointGroup.renderOrder = 2; + this.group.add(this.pointGroup); + this.pointIndex = 0; + + this.lanePath = new LanePath(); + this.rebuildPathGeometry(); + + this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK; + this.speedLimitDom.value = SPEED_LIMIT_FALLBACK; + } + + keyDown(event) { + if (event.repeat || this.editMode != 'path' && this.editMode != 'staticObstacles') return; + + if (event.key == 'Shift') { + this.removeMode = true; + this.canvas.classList.add('editor-pointing'); + event.preventDefault(); + } else if (event.key == 'Control' && this.editMode == 'staticObstacles') { + this.rotateMode = true; + this.canvas.classList.add('editor-pointing'); + event.preventDefault(); + } + } + + keyUp(event) { + if (event.key == 'Shift') { + this.removeMode = false; + this.canvas.classList.remove('editor-pointing', 'editor-removing'); + } else if (event.key == 'Control') { + this.rotateMode = false; + this.canvas.classList.remove('editor-pointing', 'editor-grabbing'); + } + } + + mouseDown(event) { + if (!this.isEnabled || event.button != 0) return; + + this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1; + this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1; + + this.raycaster.setFromCamera(this.mouse, this.camera); + + if (this.editMode == 'path') { + let picked = null; + this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => { + if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p; + }); + + if (picked) { + if (this.removeMode) { + this.removePoint(picked.object); + this.rebuildPathGeometry(); + } else { + this.canvas.classList.remove('editor-grab'); + this.canvas.classList.add('editor-grabbing'); + + this.draggingPoint = picked.object; + this.dragOffset.copy(picked.object.position).sub(picked.point); + } + } else if (!this.removeMode) { + const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE); + if (intersection != null) { + this.addPoint(new THREE.Vector2(intersection.x, intersection.z)); + this.rebuildPathGeometry(); + } + } + } else if (this.editMode == 'staticObstacles') { + let picked = null; + this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => { + if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o; + }); + + if (picked) { + if (this.removeMode) { + this.removeStaticObstacle(picked.object); + } else { + this.canvas.classList.remove('editor-grab'); + this.canvas.classList.add('editor-grabbing'); + + if (this.rotateMode) { + this.rotatingObstacle = picked.object; + this.initialObstacleRotation = picked.object.rotation.z; + this.dragOffset.set(this.mouse.x, this.mouse.y, 0); + } else { + this.draggingObstacle = picked.object; + this.dragOffset.copy(picked.object.position).sub(picked.point); + } + } + } else if (!this.removeMode && !this.rotateMode) { + const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE); + if (intersection != null) { + this.draggingObstacle = true; + this.dragOffset.copy(intersection); + } + } + } + } + + mouseMove(event) { + this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1; + this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1; + } + + mouseUp(event) { + if (!this.isEnabled || event.button != 0) return; + + if (this.draggingObstacle === true) { + this.group.remove(this.draggingObstaclePreview); + this.draggingObstaclePreview = null; + + this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1; + this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1; + + this.raycaster.setFromCamera(this.mouse, this.camera); + + const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE); + if (intersection != null) { + const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection); + this.addStaticObstacle(center, width, height); + } + } + + this.draggingPoint = null; + this.draggingObstacle = null; + this.rotatingObstacle = null; + this.canvas.classList.remove('editor-grab', 'editor-grabbing'); + } + + updateSavedInfo(name, savedAt) { + this.previousSavedName = name || null; + + name = name || 'Untitled'; + savedAt = savedAt || 'Unsaved'; + + this.scenarioNameDom.textContent = name; + this.scenarioNameDom.title = name; + this.scenarioSavedAtDom.textContent = savedAt; + } + + _changeLanePreference(pref) { + this.lanePreference = pref; + + if (pref > 0) { + this.laneLeftDom.classList.add('is-outlined'); + this.laneLeftDom.classList.remove('is-selected'); + this.laneRightDom.classList.remove('is-outlined'); + this.laneRightDom.classList.add('is-selected'); + } else { + this.laneRightDom.classList.add('is-outlined'); + this.laneRightDom.classList.remove('is-selected'); + this.laneLeftDom.classList.remove('is-outlined'); + this.laneLeftDom.classList.add('is-selected'); + } + } + + saveClicked() { + const name = window.prompt('Name your scenario:', this.previousSavedName || ''); + if (name === null) return; + if (name === '') { + window.alert('The scenario name cannot be blank.'); + return; + } + + let [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), name === this.previousSavedName); + const formattedSavedAt = formatDate(savedAt); + + if (success) { + this.updateSavedInfo(name, formattedSavedAt); + } else if (confirm(`A scenario named "${name}" already exists, last saved ${formattedSavedAt}. Do you want to overwrite it?`)) { + [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), true); + this.updateSavedInfo(name, formatDate(savedAt)); + } + } + + loadClicked() { + this.scenarioManager.showModal(); + } + + shareClicked() { + this.shareManager.showModal(this.scenarioToJSON()); + } + + _dimensionsFromRect(from, to) { + const center = from.clone().add(to).divideScalar(2); + const width = Math.max(0.5, Math.abs(from.x - to.x)); + const height = Math.max(0.5, Math.abs(from.z - to.z)); + return [center, width, height]; + } +} diff --git a/seminar06-planning/simulator/js/simulator/OrbitControls.js b/seminar06-planning/simulator/js/simulator/OrbitControls.js new file mode 100644 index 0000000..0454fe3 --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/OrbitControls.js @@ -0,0 +1,1048 @@ +/** + * @author qiao / https://github.com/qiao + * @author mrdoob / http://mrdoob.com + * @author alteredq / http://alteredqualia.com/ + * @author WestLangley / http://github.com/WestLangley + * @author erich666 / http://erichaines.com + */ + +// This set of controls performs orbiting, dollying (zooming), and panning. +// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default). +// +// Orbit - left mouse / touch: one finger move +// Zoom - middle mouse, or mousewheel / touch: two finger spread or squish +// Pan - right mouse, or arrow keys / touch: three finger swipe + +const OrbitControls = function ( object, domElement ) { + + this.object = object; + + this.domElement = ( domElement !== undefined ) ? domElement : document; + + // Set to false to disable this control + this.enabled = true; + + // "target" sets the location of focus, where the object orbits around + this.target = new THREE.Vector3(); + + // How far you can dolly in and out ( PerspectiveCamera only ) + this.minDistance = 0; + this.maxDistance = Infinity; + + // How far you can zoom in and out ( OrthographicCamera only ) + this.minZoom = 0; + this.maxZoom = Infinity; + + // How far you can orbit vertically, upper and lower limits. + // Range is 0 to Math.PI radians. + this.minPolarAngle = 0; // radians + this.maxPolarAngle = Math.PI; // radians + + // How far you can orbit horizontally, upper and lower limits. + // If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ]. + this.minAzimuthAngle = - Infinity; // radians + this.maxAzimuthAngle = Infinity; // radians + + // Set to true to enable damping (inertia) + // If damping is enabled, you must call controls.update() in your animation loop + this.enableDamping = false; + this.dampingFactor = 0.25; + + // This option actually enables dollying in and out; left as "zoom" for backwards compatibility. + // Set to false to disable zooming + this.enableZoom = true; + this.zoomSpeed = 1.0; + + // Set to false to disable rotating + this.enableRotate = true; + this.rotateSpeed = 1.0; + + // Set to false to disable panning + this.enablePan = true; + this.keyPanSpeed = 7.0; // pixels moved per arrow key push + + // Set to true to automatically rotate around the target + // If auto-rotate is enabled, you must call controls.update() in your animation loop + this.autoRotate = false; + this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60 + + // Set to false to disable use of the keys + this.enableKeys = true; + + // The four arrow keys + this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 }; + + // Mouse buttons + this.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT }; + + // for reset + this.target0 = this.target.clone(); + this.position0 = this.object.position.clone(); + this.zoom0 = this.object.zoom; + + // + // public methods + // + + this.getPolarAngle = function () { + + return spherical.phi; + + }; + + this.getAzimuthalAngle = function () { + + return spherical.theta; + + }; + + this.saveState = function () { + + scope.target0.copy( scope.target ); + scope.position0.copy( scope.object.position ); + scope.zoom0 = scope.object.zoom; + + }; + + this.reset = function () { + + scope.target.copy( scope.target0 ); + scope.object.position.copy( scope.position0 ); + scope.object.zoom = scope.zoom0; + + scope.object.updateProjectionMatrix(); + scope.dispatchEvent( changeEvent ); + + scope.update(); + + state = STATE.NONE; + + }; + + this.rotateLeft = function(angle) { + rotateLeft(angle); + } + + // this method is exposed, but perhaps it would be better if we can make it private... + this.update = function () { + + var offset = new THREE.Vector3(); + + // so camera.up is the orbit axis + var quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) ); + var quatInverse = quat.clone().inverse(); + + var lastPosition = new THREE.Vector3(); + var lastQuaternion = new THREE.Quaternion(); + + return function update() { + + var position = scope.object.position; + + offset.copy( position ).sub( scope.target ); + + // rotate offset to "y-axis-is-up" space + offset.applyQuaternion( quat ); + + // angle from z-axis around y-axis + spherical.setFromVector3( offset ); + + if ( scope.autoRotate && state === STATE.NONE ) { + + rotateLeft( getAutoRotationAngle() ); + + } + + spherical.theta += sphericalDelta.theta; + spherical.phi += sphericalDelta.phi; + + // restrict theta to be between desired limits + spherical.theta = Math.max( scope.minAzimuthAngle, Math.min( scope.maxAzimuthAngle, spherical.theta ) ); + + // restrict phi to be between desired limits + spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) ); + + spherical.makeSafe(); + + + spherical.radius *= scale; + + // restrict radius to be between desired limits + spherical.radius = Math.max( scope.minDistance, Math.min( scope.maxDistance, spherical.radius ) ); + + // move target to panned location + scope.target.add( panOffset ); + + offset.setFromSpherical( spherical ); + + // rotate offset back to "camera-up-vector-is-up" space + offset.applyQuaternion( quatInverse ); + + position.copy( scope.target ).add( offset ); + + scope.object.lookAt( scope.target ); + + if ( scope.enableDamping === true ) { + + sphericalDelta.theta *= ( 1 - scope.dampingFactor ); + sphericalDelta.phi *= ( 1 - scope.dampingFactor ); + + } else { + + sphericalDelta.set( 0, 0, 0 ); + + } + + scale = 1; + panOffset.set( 0, 0, 0 ); + + // update condition is: + // min(camera displacement, camera rotation in radians)^2 > EPS + // using small-angle approximation cos(x/2) = 1 - x^2 / 8 + + if ( zoomChanged || + lastPosition.distanceToSquared( scope.object.position ) > EPS || + 8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) { + + scope.dispatchEvent( changeEvent ); + + lastPosition.copy( scope.object.position ); + lastQuaternion.copy( scope.object.quaternion ); + zoomChanged = false; + + return true; + + } + + return false; + + }; + + }(); + + this.dispose = function () { + + scope.domElement.removeEventListener( 'contextmenu', onContextMenu, false ); + scope.domElement.removeEventListener( 'mousedown', onMouseDown, false ); + scope.domElement.removeEventListener( 'wheel', onMouseWheel, false ); + + scope.domElement.removeEventListener( 'touchstart', onTouchStart, false ); + scope.domElement.removeEventListener( 'touchend', onTouchEnd, false ); + scope.domElement.removeEventListener( 'touchmove', onTouchMove, false ); + + document.removeEventListener( 'mousemove', onMouseMove, false ); + document.removeEventListener( 'mouseup', onMouseUp, false ); + + window.removeEventListener( 'keydown', onKeyDown, false ); + + //scope.dispatchEvent( { type: 'dispose' } ); // should this be added here? + + }; + + // + // internals + // + + var scope = this; + + var changeEvent = { type: 'change' }; + var startEvent = { type: 'start' }; + var endEvent = { type: 'end' }; + + var STATE = { NONE: - 1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5 }; + + var state = STATE.NONE; + + var EPS = 0.000001; + + // current position in spherical coordinates + var spherical = new THREE.Spherical(); + var sphericalDelta = new THREE.Spherical(); + + var scale = 1; + var panOffset = new THREE.Vector3(); + var zoomChanged = false; + + var rotateStart = new THREE.Vector2(); + var rotateEnd = new THREE.Vector2(); + var rotateDelta = new THREE.Vector2(); + + var panStart = new THREE.Vector2(); + var panEnd = new THREE.Vector2(); + var panDelta = new THREE.Vector2(); + + var dollyStart = new THREE.Vector2(); + var dollyEnd = new THREE.Vector2(); + var dollyDelta = new THREE.Vector2(); + + function getAutoRotationAngle() { + + return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed; + + } + + function getZoomScale() { + + return Math.pow( 0.95, scope.zoomSpeed ); + + } + + function rotateLeft( angle ) { + + sphericalDelta.theta -= angle; + + } + + function rotateUp( angle ) { + + sphericalDelta.phi -= angle; + + } + + var panLeft = function () { + + var v = new THREE.Vector3(); + + return function panLeft( distance, objectMatrix ) { + + v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix + v.multiplyScalar( - distance ); + + panOffset.add( v ); + + }; + + }(); + + var panUp = function () { + + var v = new THREE.Vector3(); + + return function panUp( distance, objectMatrix ) { + + v.setFromMatrixColumn( objectMatrix, 1 ); // get Y column of objectMatrix + v.multiplyScalar( distance ); + + panOffset.add( v ); + + }; + + }(); + + // deltaX and deltaY are in pixels; right and down are positive + var pan = function () { + + var offset = new THREE.Vector3(); + + return function pan( deltaX, deltaY ) { + + var element = scope.domElement === document ? scope.domElement.body : scope.domElement; + + if ( scope.object.isPerspectiveCamera ) { + + // perspective + var position = scope.object.position; + offset.copy( position ).sub( scope.target ); + var targetDistance = offset.length(); + + // half of the fov is center to top of screen + targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 ); + + // we actually don't use screenWidth, since perspective camera is fixed to screen height + panLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix ); + panUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix ); + + } else if ( scope.object.isOrthographicCamera ) { + + // orthographic + panLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix ); + panUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix ); + + } else { + + // camera neither orthographic nor perspective + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' ); + scope.enablePan = false; + + } + + }; + + }(); + + function dollyIn( dollyScale ) { + + if ( scope.object.isPerspectiveCamera ) { + + scale /= dollyScale; + + } else if ( scope.object.isOrthographicCamera ) { + + scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) ); + scope.object.updateProjectionMatrix(); + zoomChanged = true; + + } else { + + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); + scope.enableZoom = false; + + } + + } + + function dollyOut( dollyScale ) { + + if ( scope.object.isPerspectiveCamera ) { + + scale *= dollyScale; + + } else if ( scope.object.isOrthographicCamera ) { + + scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) ); + scope.object.updateProjectionMatrix(); + zoomChanged = true; + + } else { + + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); + scope.enableZoom = false; + + } + + } + + // + // event callbacks - update the object state + // + + function handleMouseDownRotate( event ) { + + //console.log( 'handleMouseDownRotate' ); + + rotateStart.set( event.clientX, event.clientY ); + + } + + function handleMouseDownDolly( event ) { + + //console.log( 'handleMouseDownDolly' ); + + dollyStart.set( event.clientX, event.clientY ); + + } + + function handleMouseDownPan( event ) { + + //console.log( 'handleMouseDownPan' ); + + panStart.set( event.clientX, event.clientY ); + + } + + function handleMouseMoveRotate( event ) { + + //console.log( 'handleMouseMoveRotate' ); + + rotateEnd.set( event.clientX, event.clientY ); + rotateDelta.subVectors( rotateEnd, rotateStart ); + + var element = scope.domElement === document ? scope.domElement.body : scope.domElement; + + // rotating across whole screen goes 360 degrees around + rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed ); + + // rotating up and down along whole screen attempts to go 360, but limited to 180 + rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed ); + + rotateStart.copy( rotateEnd ); + + scope.update(); + + } + + function handleMouseMoveDolly( event ) { + + //console.log( 'handleMouseMoveDolly' ); + + dollyEnd.set( event.clientX, event.clientY ); + + dollyDelta.subVectors( dollyEnd, dollyStart ); + + if ( dollyDelta.y > 0 ) { + + dollyIn( getZoomScale() ); + + } else if ( dollyDelta.y < 0 ) { + + dollyOut( getZoomScale() ); + + } + + dollyStart.copy( dollyEnd ); + + scope.update(); + + } + + function handleMouseMovePan( event ) { + + //console.log( 'handleMouseMovePan' ); + + panEnd.set( event.clientX, event.clientY ); + + panDelta.subVectors( panEnd, panStart ); + + pan( panDelta.x, panDelta.y ); + + panStart.copy( panEnd ); + + scope.update(); + + } + + function handleMouseUp( event ) { + + // console.log( 'handleMouseUp' ); + + } + + function handleMouseWheel( event ) { + + // console.log( 'handleMouseWheel' ); + + if ( event.deltaY < 0 ) { + + dollyOut( getZoomScale() ); + + } else if ( event.deltaY > 0 ) { + + dollyIn( getZoomScale() ); + + } + + scope.update(); + + } + + function handleKeyDown( event ) { + + //console.log( 'handleKeyDown' ); + + switch ( event.keyCode ) { + + case scope.keys.UP: + pan( 0, scope.keyPanSpeed ); + scope.update(); + break; + + case scope.keys.BOTTOM: + pan( 0, - scope.keyPanSpeed ); + scope.update(); + break; + + case scope.keys.LEFT: + pan( scope.keyPanSpeed, 0 ); + scope.update(); + break; + + case scope.keys.RIGHT: + pan( - scope.keyPanSpeed, 0 ); + scope.update(); + break; + + } + + } + + function handleTouchStartRotate( event ) { + + //console.log( 'handleTouchStartRotate' ); + + rotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY ); + + } + + function handleTouchStartDolly( event ) { + + //console.log( 'handleTouchStartDolly' ); + + var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX; + var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY; + + var distance = Math.sqrt( dx * dx + dy * dy ); + + dollyStart.set( 0, distance ); + + } + + function handleTouchStartPan( event ) { + + //console.log( 'handleTouchStartPan' ); + + panStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY ); + + } + + function handleTouchMoveRotate( event ) { + + //console.log( 'handleTouchMoveRotate' ); + + rotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY ); + rotateDelta.subVectors( rotateEnd, rotateStart ); + + var element = scope.domElement === document ? scope.domElement.body : scope.domElement; + + // rotating across whole screen goes 360 degrees around + rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed ); + + // rotating up and down along whole screen attempts to go 360, but limited to 180 + rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed ); + + rotateStart.copy( rotateEnd ); + + scope.update(); + + } + + function handleTouchMoveDolly( event ) { + + //console.log( 'handleTouchMoveDolly' ); + + var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX; + var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY; + + var distance = Math.sqrt( dx * dx + dy * dy ); + + dollyEnd.set( 0, distance ); + + dollyDelta.subVectors( dollyEnd, dollyStart ); + + if ( dollyDelta.y > 0 ) { + + dollyOut( getZoomScale() ); + + } else if ( dollyDelta.y < 0 ) { + + dollyIn( getZoomScale() ); + + } + + dollyStart.copy( dollyEnd ); + + scope.update(); + + } + + function handleTouchMovePan( event ) { + + //console.log( 'handleTouchMovePan' ); + + panEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY ); + + panDelta.subVectors( panEnd, panStart ); + + pan( panDelta.x, panDelta.y ); + + panStart.copy( panEnd ); + + scope.update(); + + } + + function handleTouchEnd( event ) { + + //console.log( 'handleTouchEnd' ); + + } + + // + // event handlers - FSM: listen for events and reset state + // + + function onMouseDown( event ) { + + if ( scope.enabled === false ) return; + + event.preventDefault(); + + switch ( event.button ) { + + case scope.mouseButtons.ORBIT: + + if ( scope.enableRotate === false ) return; + + handleMouseDownRotate( event ); + + state = STATE.ROTATE; + + break; + + case scope.mouseButtons.ZOOM: + + if ( scope.enableZoom === false ) return; + + handleMouseDownDolly( event ); + + state = STATE.DOLLY; + + break; + + case scope.mouseButtons.PAN: + + if ( scope.enablePan === false ) return; + + handleMouseDownPan( event ); + + state = STATE.PAN; + + break; + + } + + if ( state !== STATE.NONE ) { + + document.addEventListener( 'mousemove', onMouseMove, false ); + document.addEventListener( 'mouseup', onMouseUp, false ); + + scope.dispatchEvent( startEvent ); + + } + + } + + function onMouseMove( event ) { + + if ( scope.enabled === false ) return; + + event.preventDefault(); + + switch ( state ) { + + case STATE.ROTATE: + + if ( scope.enableRotate === false ) return; + + handleMouseMoveRotate( event ); + + break; + + case STATE.DOLLY: + + if ( scope.enableZoom === false ) return; + + handleMouseMoveDolly( event ); + + break; + + case STATE.PAN: + + if ( scope.enablePan === false ) return; + + handleMouseMovePan( event ); + + break; + + } + + } + + function onMouseUp( event ) { + + if ( scope.enabled === false ) return; + + handleMouseUp( event ); + + document.removeEventListener( 'mousemove', onMouseMove, false ); + document.removeEventListener( 'mouseup', onMouseUp, false ); + + scope.dispatchEvent( endEvent ); + + state = STATE.NONE; + + } + + function onMouseWheel( event ) { + + if ( scope.enabled === false || scope.enableZoom === false || ( state !== STATE.NONE && state !== STATE.ROTATE ) ) return; + + event.preventDefault(); + event.stopPropagation(); + + handleMouseWheel( event ); + + scope.dispatchEvent( startEvent ); // not sure why these are here... + scope.dispatchEvent( endEvent ); + + } + + function onKeyDown( event ) { + + if ( scope.enabled === false || scope.enableKeys === false || scope.enablePan === false ) return; + + handleKeyDown( event ); + + } + + function onTouchStart( event ) { + + if ( scope.enabled === false ) return; + + switch ( event.touches.length ) { + + case 1: // one-fingered touch: rotate + + if ( scope.enableRotate === false ) return; + + handleTouchStartRotate( event ); + + state = STATE.TOUCH_ROTATE; + + break; + + case 2: // two-fingered touch: dolly + + if ( scope.enableZoom === false ) return; + + handleTouchStartDolly( event ); + + state = STATE.TOUCH_DOLLY; + + break; + + case 3: // three-fingered touch: pan + + if ( scope.enablePan === false ) return; + + handleTouchStartPan( event ); + + state = STATE.TOUCH_PAN; + + break; + + default: + + state = STATE.NONE; + + } + + if ( state !== STATE.NONE ) { + + scope.dispatchEvent( startEvent ); + + } + + } + + function onTouchMove( event ) { + + if ( scope.enabled === false ) return; + + event.preventDefault(); + event.stopPropagation(); + + switch ( event.touches.length ) { + + case 1: // one-fingered touch: rotate + + if ( scope.enableRotate === false ) return; + if ( state !== STATE.TOUCH_ROTATE ) return; // is this needed?... + + handleTouchMoveRotate( event ); + + break; + + case 2: // two-fingered touch: dolly + + if ( scope.enableZoom === false ) return; + if ( state !== STATE.TOUCH_DOLLY ) return; // is this needed?... + + handleTouchMoveDolly( event ); + + break; + + case 3: // three-fingered touch: pan + + if ( scope.enablePan === false ) return; + if ( state !== STATE.TOUCH_PAN ) return; // is this needed?... + + handleTouchMovePan( event ); + + break; + + default: + + state = STATE.NONE; + + } + + } + + function onTouchEnd( event ) { + + if ( scope.enabled === false ) return; + + handleTouchEnd( event ); + + scope.dispatchEvent( endEvent ); + + state = STATE.NONE; + + } + + function onContextMenu( event ) { + + if ( scope.enabled === false ) return; + + event.preventDefault(); + + } + + // + + scope.domElement.addEventListener( 'contextmenu', onContextMenu, false ); + + scope.domElement.addEventListener( 'mousedown', onMouseDown, false ); + scope.domElement.addEventListener( 'wheel', onMouseWheel, false ); + + scope.domElement.addEventListener( 'touchstart', onTouchStart, false ); + scope.domElement.addEventListener( 'touchend', onTouchEnd, false ); + scope.domElement.addEventListener( 'touchmove', onTouchMove, false ); + + window.addEventListener( 'keydown', onKeyDown, false ); + + // force an update at start + + this.update(); + +}; + +OrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype ); +OrbitControls.prototype.constructor = OrbitControls; + +Object.defineProperties( OrbitControls.prototype, { + + center: { + + get: function () { + + console.warn( 'OrbitControls: .center has been renamed to .target' ); + return this.target; + + } + + }, + + // backward compatibility + + noZoom: { + + get: function () { + + console.warn( 'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' ); + return ! this.enableZoom; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' ); + this.enableZoom = ! value; + + } + + }, + + noRotate: { + + get: function () { + + console.warn( 'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' ); + return ! this.enableRotate; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' ); + this.enableRotate = ! value; + + } + + }, + + noPan: { + + get: function () { + + console.warn( 'OrbitControls: .noPan has been deprecated. Use .enablePan instead.' ); + return ! this.enablePan; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .noPan has been deprecated. Use .enablePan instead.' ); + this.enablePan = ! value; + + } + + }, + + noKeys: { + + get: function () { + + console.warn( 'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' ); + return ! this.enableKeys; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' ); + this.enableKeys = ! value; + + } + + }, + + staticMoving: { + + get: function () { + + console.warn( 'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' ); + return ! this.enableDamping; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' ); + this.enableDamping = ! value; + + } + + }, + + dynamicDampingFactor: { + + get: function () { + + console.warn( 'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' ); + return this.dampingFactor; + + }, + + set: function ( value ) { + + console.warn( 'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' ); + this.dampingFactor = value; + + } + + } + +} ); + +export default OrbitControls; diff --git a/seminar06-planning/simulator/js/simulator/PathPlannerConfigEditor.js b/seminar06-planning/simulator/js/simulator/PathPlannerConfigEditor.js new file mode 100644 index 0000000..721ba05 --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/PathPlannerConfigEditor.js @@ -0,0 +1,159 @@ +import Car from "../physics/Car.js"; + +const LOCAL_STORAGE_KEY = 'dash_PathPlannerConfig'; + +const internalConfig = { + lattice: { + numStations: 8, + numLatitudes: 17, + stationConnectivity: 3, + latitudeConnectivity: 7 + }, + + roadWidth: 3.7 * 2, // meters + + numDynamicFrames: 20, + numDynamicSubframes: 4, + + dCurvatureMax: Car.MAX_STEER_SPEED / Car.WHEEL_BASE, + rearAxleToCenter: -Car.REAR_AXLE_POS +}; + +const defaultConfig = { + spatialHorizon: 120, // meters + centerlineStationInterval: 0.5, // meters + + xyGridCellSize: 0.3, // meters + slGridCellSize: 0.15, // meters + gridMargin: 20, // meters + pathSamplingStep: 1, // meters + + cubicPathPenalty: 0, + + collisionDilationS: Car.HALF_CAR_LENGTH + 2, // meters + hazardDilationS: 8, // meters + collisionDilationL: Car.HALF_CAR_WIDTH + 0.5, //meters + hazardDilationL: 0.5, // meters + + dynamicHazardDilationS: 16, + dynamicHazardDilationL: 0.5, + + obstacleHazardCost: 200, + + laneCenterLatitude: internalConfig.roadWidth / 4, + laneShoulderLatitude: internalConfig.roadWidth / 2 * 1.1 - Car.HALF_CAR_WIDTH, + laneCostSlope: 20, // cost / meter + lanePreferenceDiscount: 55, + + stationReachDiscount: 400, + extraTimePenalty: 1000, + + hysteresisDiscount: 50, + + speedLimitPenalty: 200, + + hardAccelerationPenalty: 70, + hardDecelerationPenalty: 50, + + softLateralAccelerationLimit: 4, // m/s^2 + softLateralAccelerationPenalty: 100, + linearLateralAccelerationPenalty: 10, + + accelerationChangePenalty: 10 +}; + +export default class PathPlannerConfigEditor { + constructor() { + this._config = Object.assign({}, defaultConfig); + + this.showConfigBox = document.getElementById('show-config-box'); + this.configBox = document.getElementById('config-box-content'); + this.configForm = document.getElementById('config-form'); + + this._setUpButtons(); + + let storedConfig = {}; + try { + storedConfig = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_KEY)) || {}; + } catch (e) {} + + for (const key of Object.keys(this._config).sort()) { + if (storedConfig[key] !== undefined) this._config[key] = storedConfig[key]; + this.configForm.appendChild(this._createConfigField(key, this._config[key])); + } + } + + get config() { + return Object.assign({}, this._config, internalConfig); + } + + _setUpButtons() { + document.getElementById('show-config-button').addEventListener('click', e => { + this.showConfigBox.classList.add('is-hidden'); + this.configBox.classList.remove('is-hidden'); + }); + + document.getElementById('hide-config-button').addEventListener('click', e => { + this.showConfigBox.classList.remove('is-hidden'); + this.configBox.classList.add('is-hidden'); + }); + + document.getElementById('save-config-button').addEventListener('click', this._saveConfigFields.bind(this)); + document.getElementById('restore-defaults-config-button').addEventListener('click', this._restoreDefaults.bind(this)); + } + + _createConfigField(key, value) { + const html = + `
+
+ +
+
+
+
+ +
+
+
+
`; + + const template = document.createElement('template'); + template.innerHTML = html; + return template.content.firstChild; + } + + _saveConfigFields() { + const formData = new FormData(this.configForm); + + for (const [k, v] of formData.entries()) { + const parsedValue = Number.parseFloat(v); + this._config[k] = parsedValue + + const fieldDom = document.getElementById(`config-field-${k}`); + if (parsedValue === defaultConfig[k]) + fieldDom.classList.remove('is-danger'); + else + fieldDom.classList.add('is-danger'); + } + + try { + window.localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(this._config)); + } catch (e) {} + } + + _restoreDefaults() { + this._config = Object.assign({}, defaultConfig); + + try { + window.localStorage.removeItem(LOCAL_STORAGE_KEY); + } catch (e) {} + + while (this.configForm.firstChild) + this.configForm.removeChild(this.configForm.firstChild); + + for (const key of Object.keys(this._config).sort()) + this.configForm.appendChild(this._createConfigField(key, this._config[key])); + } +} + +PathPlannerConfigEditor.internalConfig = internalConfig; diff --git a/seminar06-planning/simulator/js/simulator/ScenarioManager.js b/seminar06-planning/simulator/js/simulator/ScenarioManager.js new file mode 100644 index 0000000..eeab586 --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/ScenarioManager.js @@ -0,0 +1,252 @@ +import { formatDate } from "../Helpers.js"; +import EXAMPLES from "./examples.js"; + +const LOCAL_STORAGE_KEY = 'dash_Scenarios'; + +export default class ScenarioManager { + constructor(editor) { + this.editor = editor; + this.modal = document.getElementById('scenarios-modal'); + + document.getElementById('scenarios-modal-background').addEventListener('click', this._closeModal.bind(this)); + document.getElementById('scenarios-modal-close').addEventListener('click', this._closeModal.bind(this)); + + this.examplesTab = document.getElementById('scenarios-modal-examples-tab'); + this.savedTab = document.getElementById('scenarios-modal-saved-tab'); + this.importTab = document.getElementById('scenarios-modal-import-tab'); + + this.examplesTabButton = document.getElementById('scenarios-modal-examples-tab-button'); + this.savedTabButton = document.getElementById('scenarios-modal-saved-tab-button'); + this.importTabButton = document.getElementById('scenarios-modal-import-tab-button'); + this.examplesTabButton.addEventListener('click', e => this.switchTab(this.examplesTab)); + this.savedTabButton.addEventListener('click', e => this.switchTab(this.savedTab)); + this.importTabButton.addEventListener('click', e => this.switchTab(this.importTab)); + + this.itemsContainer = document.getElementById('scenarios-modal-items'); + + this.sortName = document.getElementById('scenarios-sort-name'); + this.sortName.addEventListener('click', e => this._buildScenarioItems('name')); + this.sortSavedAt = document.getElementById('scenarios-sort-saved-at'); + this.sortSavedAt.addEventListener('click', e => this._buildScenarioItems('savedAt')); + + this.importBox = document.getElementById('scenario-import-box'); + this.importInfo = document.getElementById('scenario-import-info'); + + this.importBox.addEventListener('input', this._importBoxChanged.bind(this)); + + for (let i = 0; i < EXAMPLES.length; i++) + document.getElementById(`example-${i}`).addEventListener('click', e => this._loadScenario(EXAMPLES[i])); + } + + switchTab(tab) { + this.examplesTab.classList.add('is-hidden') + this.savedTab.classList.add('is-hidden') + this.importTab.classList.add('is-hidden') + this.examplesTabButton.classList.remove('is-active'); + this.savedTabButton.classList.remove('is-active'); + this.importTabButton.classList.remove('is-active'); + + let button = this.savedTabButton; + if (tab == this.examplesTab) + button = this.examplesTabButton; + else if (tab == this.importTab) + button = this.importTabButton; + + tab.classList.remove('is-hidden'); + button.classList.add('is-active'); + + if (tab == this.importTab) + this.importBox.focus(); + } + + saveScenario(name, data, force = false) { + const scenarios = this.fetchScenarios(); + let scenario = scenarios[name]; + const now = new Date(); + + if (scenario) { + if (!force) return [false, scenario.savedAt]; + + scenario.data = data; + scenario.savedAt = now; + } else { + scenario = { + name: name, + data: data, + savedAt: now + }; + + scenarios[name] = scenario; + } + + const json = JSON.stringify(scenarios); + window.localStorage.setItem(LOCAL_STORAGE_KEY, json); + + return [true, scenario.savedAt]; + } + + fetchScenarios() { + const scenarios = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_KEY)) || {}; + + for (const k in scenarios) + scenarios[k].savedAt = new Date(scenarios[k].savedAt); + + return scenarios; + } + + showModal(onLoadScenario = null) { + this.onLoadScenario = onLoadScenario; + + this.modal.classList.add('is-active'); + this.switchTab(this.savedTab); + + this._buildScenarioItems(); + this.itemsContainer.scrollTop = 0; + + this.importBox.value = ''; + this.importBox.dispatchEvent(new Event('input')); + } + + _closeModal() { + this.onLoadScenario = null; + this.modal.classList.remove('is-active'); + } + + _buildScenarioItems(sort = 'savedAt') { + this.itemsContainer.innerHTML = ''; + + this.sortName.classList.remove('is-underlined'); + this.sortSavedAt.classList.remove('is-underlined'); + if (sort == 'name') + this.sortName.classList.add('is-underlined'); + else if (sort == 'savedAt') + this.sortSavedAt.classList.add('is-underlined'); + + const scenarios = Object.values(this.fetchScenarios()); + + if (scenarios.length == 0) { + this._showEmptyMessage(); + } else { + scenarios.sort((a, b) => { + if (sort == 'savedAt') { + if (a.savedAt < b.savedAt) return +1; + else if (b.savedAt < a.savedAt) return -1; + } + + const nameA = a.name.toLowerCase(); + const nameB = b.name.toLowerCase(); + + if (nameA < nameB) return -1; + if (nameB < nameA) return +1; + return 0; + }); + + scenarios.forEach(s => this._addScenarioItem(s)); + } + } + + _showEmptyMessage() { + this.itemsContainer.innerHTML = "You don't have any saved scenarios."; + } + + _addScenarioItem(scenario) { + const html = + `
+
+
+
+
+

+ + + + + +

+
+
+
`; + + const template = document.createElement('template'); + template.innerHTML = html; + const item = template.content.firstChild; + + const nameDom = item.getElementsByClassName('scenario-item-name')[0]; + nameDom.textContent = scenario.name; + nameDom.title = scenario.name; + + item.getElementsByClassName('scenario-item-saved-at')[0].textContent = formatDate(scenario.savedAt); + + item.getElementsByClassName('scenario-item-load')[0].addEventListener('click', e => this._loadScenario(scenario)); + + item.getElementsByClassName('scenario-item-delete')[0].addEventListener('click', e => { + if (window.confirm(`Are you sure you want to delete the scenario "${scenario.name}"?`)) { + this._deleteScenario(scenario); + this.itemsContainer.removeChild(item); + + if (this.itemsContainer.children.length == 0) + this._showEmptyMessage(); + } + }); + + this.itemsContainer.appendChild(item); + } + + _loadScenario(scenario) { + this.editor.loadJSON(scenario.data); + this.editor.updateSavedInfo(scenario.name, formatDate(scenario.savedAt)); + + if (this.onLoadScenario) this.onLoadScenario(); + + this._closeModal(); + } + + _deleteScenario(scenario) { + const scenarios = this.fetchScenarios(); + delete scenarios[scenario.name]; + + const json = JSON.stringify(scenarios); + window.localStorage.setItem(LOCAL_STORAGE_KEY, json); + } + + _importBoxChanged() { + this.importBox.classList.remove('is-danger'); + this.importInfo.classList.add('is-hidden'); + + const encoded = this.importBox.value; + + if (encoded != '') { + try { + const json = JSON.parse(atob(this.importBox.value)); + + if (json.s === undefined || json.d === undefined || json.p === undefined || json.p.length % 2 != 0) + throw new Error(); + + this.importInfo.innerHTML = ` +
+ Road Length: ${json.l.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 })}m +
+   +
+ Static Obstacles: ${json.s.length} +
+   +
+ Dynamic Obstacles: ${json.d.length} +
+
+ + + + Import +
+ `; + + this.importInfo.getElementsByClassName('scenario-import-button')[0].addEventListener('click', e => this._loadScenario({ data: json })); + this.importInfo.classList.remove('is-hidden'); + } catch (e) { + this.importBox.classList.add('is-danger'); + } + } + } +} diff --git a/seminar06-planning/simulator/js/simulator/ShareManager.js b/seminar06-planning/simulator/js/simulator/ShareManager.js new file mode 100644 index 0000000..ddfe4ca --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/ShareManager.js @@ -0,0 +1,49 @@ +export default class ShareManager { + constructor() { + this.modal = document.getElementById('scenario-share-modal'); + this.linkDom = document.getElementById('scenario-share-link'); + this.boxDom = document.getElementById('scenario-share-box'); + this.clipboardButton = document.getElementById('scenario-share-clipboard'); + this.clipboardIcon = document.getElementById('scenario-share-clipboard-icon'); + this.clipboardSuccessIcon = document.getElementById('scenario-share-clipboard-success-icon'); + + document.getElementById('scenario-share-modal-background').addEventListener('click', this._closeModal.bind(this)); + document.getElementById('scenario-share-modal-close').addEventListener('click', this._closeModal.bind(this)); + this.clipboardButton.addEventListener('click', this._copyLinkToClipboard.bind(this)); + + this.linkDom.addEventListener('focus', e => this.linkDom.select()); + this.boxDom.addEventListener('focus', e => this.boxDom.select()); + } + + showModal(scenario) { + this.modal.classList.add('is-active'); + + this.clipboardIcon.classList.remove('is-hidden'); + this.clipboardSuccessIcon.classList.add('is-hidden'); + this.clipboardButton.classList.remove('is-success'); + + const code = btoa(JSON.stringify(scenario)); + + const url = new URL(window.location); + url.search = ''; + url.hash = '/s/' + encodeURIComponent(code); + + this.linkDom.value = url.href; + this.boxDom.value = code; + } + + _closeModal() { + this.modal.classList.remove('is-active'); + } + + _copyLinkToClipboard() { + this.linkDom.focus(); + this.linkDom.select(); + + if (document.execCommand('copy', false, null)) { + this.clipboardIcon.classList.add('is-hidden'); + this.clipboardSuccessIcon.classList.remove('is-hidden'); + this.clipboardButton.classList.add('is-success'); + } + } +} diff --git a/seminar06-planning/simulator/js/simulator/TopDownCameraControls.js b/seminar06-planning/simulator/js/simulator/TopDownCameraControls.js new file mode 100644 index 0000000..255fb54 --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/TopDownCameraControls.js @@ -0,0 +1,66 @@ +const groundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0)); +let panning = false; + +export default class TopDownCameraControls { + constructor(domElement, camera) { + this.domElement = domElement; + this.camera = camera; + this.enablePanning = false; + this.enabled = true; + + this.minAltitude = Number.NEGATIVE_INFINITY; + this.maxAltitude = Number.POSITIVE_INFINITY; + + this.mouseDown = this.mouseDown.bind(this); + this.mouseMove = this.mouseMove.bind(this); + this.mouseUp = this.mouseUp.bind(this); + this.wheel = this.wheel.bind(this); + + this.domElement.addEventListener('mousedown', this.mouseDown); + this.domElement.addEventListener('mousemove', this.mouseMove); + this.domElement.addEventListener('mouseup', this.mouseUp); + this.domElement.addEventListener('wheel', this.wheel); + } + + reset(prevCamera) { + const lookAt = new THREE.Vector3(0, 0, -1); + lookAt.applyQuaternion(prevCamera.quaternion); + + const ray = new THREE.Ray(prevCamera.position, lookAt); + const intersection = ray.intersectPlane(groundPlane); + + if (intersection) { + this.camera.position.set(intersection.x, 50, intersection.z); + } else { + this.camera.position.y = 50; + } + + this.camera.rotation.set(-Math.PI / 2, 0, 0); + } + + mouseDown(event) { + if (!this.enabled || !this.enablePanning || event.button != 2) return; + panning = true; + } + + mouseMove(event) { + if (panning) { + const distance = 2 * this.camera.position.y * Math.tan((this.camera.fov / 2) * Math.PI / 180) / this.domElement.clientHeight; + this.camera.position.x -= distance * event.movementX; + this.camera.position.z -= distance * event.movementY; + } + } + + mouseUp(event) { + if (event.button != 2) return; + panning = false; + } + + wheel(event) { + if (!this.enabled) return; + + event.preventDefault(); + + this.camera.position.y = Math.max(this.minAltitude, Math.min(this.maxAltitude, this.camera.position.y * Math.pow(0.995, -event.deltaY))); + } +} diff --git a/seminar06-planning/simulator/js/simulator/examples.js b/seminar06-planning/simulator/js/simulator/examples.js new file mode 100644 index 0000000..59b82dc --- /dev/null +++ b/seminar06-planning/simulator/js/simulator/examples.js @@ -0,0 +1,17 @@ +export default [ + { 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} }, + + { 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} }, + + { 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} }, + + { 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} }, + + { 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} }, + + { 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} }, + + { 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} }, + + { 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} } +]; diff --git a/seminar06-planning/simulator/models/suv.js b/seminar06-planning/simulator/models/suv.js new file mode 100644 index 0000000..3953249 --- /dev/null +++ b/seminar06-planning/simulator/models/suv.js @@ -0,0 +1 @@ +export default 'data:text/plain;base64,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'; diff --git a/seminar06-planning/simulator/package-lock.json b/seminar06-planning/simulator/package-lock.json new file mode 100644 index 0000000..3ddbdaf --- /dev/null +++ b/seminar06-planning/simulator/package-lock.json @@ -0,0 +1,14441 @@ +{ + "name": "dash", + "version": "1.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "dash", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "ncu": "^0.2.1", + "npm": "^10.5.2", + "npm-check-updates": "^16.14.17" + }, + "devDependencies": { + "script-loader": "^0.7.2", + "webpack": "^5.90.3", + "webpack-cli": "^5.1.4", + "wrapper-webpack-plugin": "2.2.2" + } + }, + "node_modules/@colors/colors": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz", + "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==", + "optional": true, + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/@discoveryjs/json-ext": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz", + "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==", + "dev": true, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/@gar/promisify": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz", + "integrity": "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==" + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@isaacs/cliui/node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", + "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", + "dev": true, + "dependencies": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", + "dev": true, + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "dev": true, + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@npmcli/fs": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.0.tgz", + "integrity": "sha512-7kZUAaLscfgbwBQRbvdMYaZOWyMEcPTH/tJjnyAWJ/dvvs9Ef+CERx/qJb9GExJpl1qipaDGn7KqHnFGGixd0w==", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/git": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-4.1.0.tgz", + "integrity": "sha512-9hwoB3gStVfa0N31ymBmrX+GuDGdVA/QWShZVqE0HK2Af+7QGGrCTbZia/SW0ImUTjTne7SP91qxDmtXvDHRPQ==", + "dependencies": { + "@npmcli/promise-spawn": "^6.0.0", + "lru-cache": "^7.4.4", + "npm-pick-manifest": "^8.0.0", + "proc-log": "^3.0.0", + "promise-inflight": "^1.0.1", + "promise-retry": "^2.0.1", + "semver": "^7.3.5", + "which": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/git/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/@npmcli/git/node_modules/which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/installed-package-contents": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/installed-package-contents/-/installed-package-contents-2.0.2.tgz", + "integrity": "sha512-xACzLPhnfD51GKvTOOuNX2/V4G4mz9/1I2MfDoye9kBM3RYe5g2YbscsaGoTlaWqkxeiapBWyseULVKpSVHtKQ==", + "dependencies": { + "npm-bundled": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "bin": { + "installed-package-contents": "lib/index.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/move-file": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-2.0.1.tgz", + "integrity": "sha512-mJd2Z5TjYWq/ttPLLGqArdtnC74J6bOzg4rMDnN+p1xTacZ2yPRCk2y0oSWQtygLR9YVQXgOcONrwtnk3JupxQ==", + "deprecated": "This functionality has been moved to @npmcli/fs", + "dependencies": { + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/@npmcli/move-file/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@npmcli/move-file/node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@npmcli/node-gyp": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-3.0.0.tgz", + "integrity": "sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/promise-spawn": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-6.0.2.tgz", + "integrity": "sha512-gGq0NJkIGSwdbUt4yhdF8ZrmkGKVz9vAdVzpOfnom+V8PLSmSOVhZwbNvZZS1EYcJN5hzzKBxmmVVAInM6HQLg==", + "dependencies": { + "which": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/promise-spawn/node_modules/which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/run-script": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-6.0.2.tgz", + "integrity": "sha512-NCcr1uQo1k5U+SYlnIrbAh3cxy+OQT1VtqiAbxdymSlptbzBb62AjH2xXgjNCoP073hoa1CfCAcwoZ8k96C4nA==", + "dependencies": { + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/promise-spawn": "^6.0.0", + "node-gyp": "^9.0.0", + "read-package-json-fast": "^3.0.0", + "which": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/run-script/node_modules/which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@pnpm/config.env-replace": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz", + "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==", + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz", + "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==", + "dependencies": { + "graceful-fs": "4.2.10" + }, + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" + }, + "node_modules/@pnpm/npm-conf": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.2.2.tgz", + "integrity": "sha512-UA91GwWPhFExt3IizW6bOeY/pQ0BkuNwKjk9iQW9KqxluGCrg4VenZ0/L+2Y0+ZOtme72EVvg6v0zo3AMQRCeA==", + "dependencies": { + "@pnpm/config.env-replace": "^1.1.0", + "@pnpm/network.ca-file": "^1.0.1", + "config-chain": "^1.1.11" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@sigstore/bundle": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-1.1.0.tgz", + "integrity": "sha512-PFutXEy0SmQxYI4texPw3dd2KewuNqv7OuK1ZFtY2fM754yhvG2KdgwIhRnoEE2uHdtdGNQ8s0lb94dW9sELog==", + "dependencies": { + "@sigstore/protobuf-specs": "^0.2.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/protobuf-specs": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.2.1.tgz", + "integrity": "sha512-XTWVxnWJu+c1oCshMLwnKvz8ZQJJDVOlciMfgpJBQbThVjKTCG8dwyhgLngBD2KN0ap9F/gOV8rFDEx8uh7R2A==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/sign": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-1.0.0.tgz", + "integrity": "sha512-INxFVNQteLtcfGmcoldzV6Je0sbbfh9I16DM4yJPw3j5+TFP8X6uIiA18mvpEa9yyeycAKgPmOA3X9hVdVTPUA==", + "dependencies": { + "@sigstore/bundle": "^1.1.0", + "@sigstore/protobuf-specs": "^0.2.0", + "make-fetch-happen": "^11.0.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/tuf": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@sigstore/tuf/-/tuf-1.0.3.tgz", + "integrity": "sha512-2bRovzs0nJZFlCN3rXirE4gwxCn97JNjMmwpecqlbgV9WcxX7WRuIrgzx/X7Ib7MYRbyUTpBYE0s2x6AmZXnlg==", + "dependencies": { + "@sigstore/protobuf-specs": "^0.2.0", + "tuf-js": "^1.1.7" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@sindresorhus/is": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz", + "integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz", + "integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==", + "dependencies": { + "defer-to-connect": "^2.0.1" + }, + "engines": { + "node": ">=14.16" + } + }, + "node_modules/@tootallnate/once": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz", + "integrity": "sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==", + "engines": { + "node": ">= 10" + } + }, + "node_modules/@tufjs/canonical-json": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@tufjs/canonical-json/-/canonical-json-1.0.0.tgz", + "integrity": "sha512-QTnf++uxunWvG2z3UFNzAoQPHxnSXOwtaI3iJ+AohhV+5vONuArPjJE7aPXPVXfXJsqrVbZBu9b81AJoSd09IQ==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@tufjs/models": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@tufjs/models/-/models-1.0.4.tgz", + "integrity": "sha512-qaGV9ltJP0EO25YfFUPhxRVK0evXFIAGicsVXuRim4Ed9cjPxYhNnNJ49SFmbeLgtxpslIkX317IgpfcHPVj/A==", + "dependencies": { + "@tufjs/canonical-json": "1.0.0", + "minimatch": "^9.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@tufjs/models/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@tufjs/models/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@types/eslint": { + "version": "8.56.5", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.56.5.tgz", + "integrity": "sha512-u5/YPJHo1tvkSF2CE0USEkxon82Z5DBy2xR+qfyYNszpX9qcs4sT6uq2kBbj4BXY1+DBGDPnrhMZV3pKWGNukw==", + "dev": true, + "dependencies": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "node_modules/@types/eslint-scope": { + "version": "3.7.7", + "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz", + "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==", + "dev": true, + "dependencies": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz", + "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==", + "dev": true + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", + "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true + }, + "node_modules/@types/node": { + "version": "20.11.28", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.28.tgz", + "integrity": "sha512-M/GPWVS2wLkSkNHVeLkrF2fD5Lx5UC4PxA0uZcKc6QqbIQUJyW1jVjueJYi1z8n0I5PxYrtpnPnWglE+y9A0KA==", + "dev": true, + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@webassemblyjs/ast": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz", + "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==", + "dev": true, + "dependencies": { + "@webassemblyjs/helper-numbers": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6" + } + }, + "node_modules/@webassemblyjs/floating-point-hex-parser": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz", + "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==", + "dev": true + }, + "node_modules/@webassemblyjs/helper-api-error": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz", + "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==", + "dev": true + }, + "node_modules/@webassemblyjs/helper-buffer": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz", + "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==", + "dev": true + }, + "node_modules/@webassemblyjs/helper-numbers": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz", + "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==", + "dev": true, + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": "1.11.6", + "@webassemblyjs/helper-api-error": "1.11.6", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/helper-wasm-bytecode": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz", + "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==", + "dev": true + }, + "node_modules/@webassemblyjs/helper-wasm-section": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz", + "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/wasm-gen": "1.12.1" + } + }, + "node_modules/@webassemblyjs/ieee754": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz", + "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==", + "dev": true, + "dependencies": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "node_modules/@webassemblyjs/leb128": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz", + "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==", + "dev": true, + "dependencies": { + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/utf8": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz", + "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==", + "dev": true + }, + "node_modules/@webassemblyjs/wasm-edit": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz", + "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/helper-wasm-section": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-opt": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1", + "@webassemblyjs/wast-printer": "1.12.1" + } + }, + "node_modules/@webassemblyjs/wasm-gen": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz", + "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "node_modules/@webassemblyjs/wasm-opt": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz", + "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1" + } + }, + "node_modules/@webassemblyjs/wasm-parser": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz", + "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-api-error": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "node_modules/@webassemblyjs/wast-printer": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz", + "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==", + "dev": true, + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", + "dev": true + }, + "node_modules/@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", + "dev": true + }, + "node_modules/abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "node_modules/acorn": { + "version": "8.11.3", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz", + "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-import-assertions": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz", + "integrity": "sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==", + "dev": true, + "peerDependencies": { + "acorn": "^8" + } + }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/agent-base/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/agent-base/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/agentkeepalive": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.5.0.tgz", + "integrity": "sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==", + "dependencies": { + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true, + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/ansi-align": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz", + "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==", + "dependencies": { + "string-width": "^4.1.0" + } + }, + "node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==" + }, + "node_modules/are-we-there-yet": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz", + "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==", + "dependencies": { + "delegates": "^1.0.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/are-we-there-yet/node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/asn1": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz", + "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==", + "dependencies": { + "safer-buffer": "~2.1.0" + } + }, + "node_modules/assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==", + "engines": { + "node": "*" + } + }, + "node_modules/aws4": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz", + "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==" + }, + "node_modules/balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "node_modules/bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==", + "dependencies": { + "tweetnacl": "^0.14.3" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==" + }, + "node_modules/boxen": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz", + "integrity": "sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==", + "dependencies": { + "ansi-align": "^3.0.1", + "camelcase": "^7.0.1", + "chalk": "^5.2.0", + "cli-boxes": "^3.0.0", + "string-width": "^5.1.2", + "type-fest": "^2.13.0", + "widest-line": "^4.0.1", + "wrap-ansi": "^8.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/boxen/node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/boxen/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz", + "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001587", + "electron-to-chromium": "^1.4.668", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==" + }, + "node_modules/builtins": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/builtins/-/builtins-5.0.1.tgz", + "integrity": "sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==", + "dependencies": { + "semver": "^7.0.0" + } + }, + "node_modules/cacheable-lookup": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz", + "integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==", + "engines": { + "node": ">=14.16" + } + }, + "node_modules/cacheable-request": { + "version": "10.2.14", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz", + "integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==", + "dependencies": { + "@types/http-cache-semantics": "^4.0.2", + "get-stream": "^6.0.1", + "http-cache-semantics": "^4.1.1", + "keyv": "^4.5.3", + "mimic-response": "^4.0.0", + "normalize-url": "^8.0.0", + "responselike": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + } + }, + "node_modules/camelcase": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz", + "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001598", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001598.tgz", + "integrity": "sha512-j8mQRDziG94uoBfeFuqsJUNECW37DXpnvhcMJMdlH2u3MRkq1sAI0LJcXP1i/Py0KbSIC4UDj8YHPrTn5YsL+Q==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ] + }, + "node_modules/caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "node_modules/chalk": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/cheerio": { + "version": "0.22.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.22.0.tgz", + "integrity": "sha512-8/MzidM6G/TgRelkzDG13y3Y9LxBjCb+8yOEZ9+wwq5gVF2w2pV0wmHvjfT0RvuxGyR7UEuK36r+yYMbT4uKgA==", + "dependencies": { + "css-select": "~1.2.0", + "dom-serializer": "~0.1.0", + "entities": "~1.1.1", + "htmlparser2": "^3.9.1", + "lodash.assignin": "^4.0.9", + "lodash.bind": "^4.1.4", + "lodash.defaults": "^4.0.1", + "lodash.filter": "^4.4.0", + "lodash.flatten": "^4.2.0", + "lodash.foreach": "^4.3.0", + "lodash.map": "^4.4.0", + "lodash.merge": "^4.4.0", + "lodash.pick": "^4.2.1", + "lodash.reduce": "^4.4.0", + "lodash.reject": "^4.4.0", + "lodash.some": "^4.4.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/chrome-trace-event": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz", + "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==", + "dev": true, + "engines": { + "node": ">=6.0" + } + }, + "node_modules/ci-info": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "engines": { + "node": ">=8" + } + }, + "node_modules/clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "engines": { + "node": ">=6" + } + }, + "node_modules/cli-boxes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz", + "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-table3": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz", + "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==", + "dependencies": { + "string-width": "^4.2.0" + }, + "engines": { + "node": "10.* || >= 12.*" + }, + "optionalDependencies": { + "@colors/colors": "1.5.0" + } + }, + "node_modules/clone-deep": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz", + "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==", + "dev": true, + "dependencies": { + "is-plain-object": "^2.0.4", + "kind-of": "^6.0.2", + "shallow-clone": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/color-support": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", + "bin": { + "color-support": "bin.js" + } + }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "node_modules/config-chain": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz", + "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==", + "dependencies": { + "ini": "^1.3.4", + "proto-list": "~1.2.1" + } + }, + "node_modules/config-chain/node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + }, + "node_modules/configstore": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-6.0.0.tgz", + "integrity": "sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==", + "dependencies": { + "dot-prop": "^6.0.1", + "graceful-fs": "^4.2.6", + "unique-string": "^3.0.0", + "write-file-atomic": "^3.0.3", + "xdg-basedir": "^5.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/yeoman/configstore?sponsor=1" + } + }, + "node_modules/console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==" + }, + "node_modules/core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/crypto-random-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-4.0.0.tgz", + "integrity": "sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==", + "dependencies": { + "type-fest": "^1.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/crypto-random-string/node_modules/type-fest": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz", + "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/css-select": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-1.2.0.tgz", + "integrity": "sha512-dUQOBoqdR7QwV90WysXPLXG5LO7nhYBgiWVfxF80DKPF8zx1t/pUd2FYy73emg3zrjtM6dzmYgbHKfV2rxiHQA==", + "dependencies": { + "boolbase": "~1.0.0", + "css-what": "2.1", + "domutils": "1.5.1", + "nth-check": "~1.0.1" + } + }, + "node_modules/css-what": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-2.1.3.tgz", + "integrity": "sha512-a+EPoD+uZiNfh+5fxw2nO9QwFa6nJe2Or35fGY6Ipw1R3R4AGz1d1TEZrCegvw2YTmZ0jXirGYlzxxpYSHwpEg==", + "engines": { + "node": "*" + } + }, + "node_modules/dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==", + "dependencies": { + "assert-plus": "^1.0.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", + "engines": { + "node": ">=10" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==" + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/dom-serializer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.1.tgz", + "integrity": "sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==", + "dependencies": { + "domelementtype": "^1.3.0", + "entities": "^1.1.1" + } + }, + "node_modules/domelementtype": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.1.tgz", + "integrity": "sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==" + }, + "node_modules/domhandler": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.4.2.tgz", + "integrity": "sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==", + "dependencies": { + "domelementtype": "1" + } + }, + "node_modules/domutils": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz", + "integrity": "sha512-gSu5Oi/I+3wDENBsOWBiRK1eoGxcywYSqg3rR960/+EfY0CF4EX1VPkgHOZ3WiS/Jg2DtliF6BhWcHlfpYUcGw==", + "dependencies": { + "dom-serializer": "0", + "domelementtype": "1" + } + }, + "node_modules/dot-prop": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz", + "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==", + "dependencies": { + "is-obj": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" + }, + "node_modules/ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==", + "dependencies": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.708", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.708.tgz", + "integrity": "sha512-iWgEEvREL4GTXXHKohhh33+6Y8XkPI5eHihDmm8zUk5Zo7HICEW+wI/j5kJ2tbuNUCXJ/sNXa03ajW635DiJXA==", + "dev": true + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/encoding": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", + "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", + "optional": true, + "dependencies": { + "iconv-lite": "^0.6.2" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.16.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.16.0.tgz", + "integrity": "sha512-O+QWCviPNSSLAD9Ucn8Awv+poAkqn3T1XY5/N7kR7rQO9yfSGWkYZDwpJ+iKF7B8rxaQKWngSqACpgzeapSyoA==", + "dev": true, + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz", + "integrity": "sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==" + }, + "node_modules/env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "engines": { + "node": ">=6" + } + }, + "node_modules/envinfo": { + "version": "7.11.1", + "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.11.1.tgz", + "integrity": "sha512-8PiZgZNIB4q/Lw4AhOvAfB/ityHAd2bli3lESSWmWSzSsl5dKpy5N1d1Rfkd2teq/g9xN90lc6o98DOjMeYHpg==", + "dev": true, + "bin": { + "envinfo": "dist/cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/err-code": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", + "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==" + }, + "node_modules/es-module-lexer": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.4.1.tgz", + "integrity": "sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==", + "dev": true + }, + "node_modules/escalade": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz", + "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-goat": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-goat/-/escape-goat-4.0.0.tgz", + "integrity": "sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esrecurse/node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "dev": true, + "engines": { + "node": ">=0.8.x" + } + }, + "node_modules/exponential-backoff": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.1.tgz", + "integrity": "sha512-dX7e/LHVJ6W3DE1MHWi9S1EYzDESENfLrYohG2G++ovZrYOkm4Knwa0mc1cn84xJOR4KEU0WSchhLbd0UklbHw==" + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + }, + "node_modules/extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==", + "engines": [ + "node >=0.6.0" + ] + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" + }, + "node_modules/fast-glob": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fast-glob/node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-glob/node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/fast-glob/node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/fast-glob/node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/fast-glob/node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "node_modules/fast-memoize": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/fast-memoize/-/fast-memoize-2.5.2.tgz", + "integrity": "sha512-Ue0LwpDYErFbmNnZSF0UH6eImUwDmogUO1jyE+JbN2gsQz/jICm1Ve7t9QT0rNSsfJt+Hs4/S3GnsDVjL4HVrw==" + }, + "node_modules/fastest-levenshtein": { + "version": "1.0.16", + "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz", + "integrity": "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==", + "dev": true, + "engines": { + "node": ">= 4.9.1" + } + }, + "node_modules/fastq": { + "version": "1.17.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz", + "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true, + "bin": { + "flat": "cli.js" + } + }, + "node_modules/foreground-child": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz", + "integrity": "sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==", + "dependencies": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=", + "engines": { + "node": "*" + } + }, + "node_modules/form-data": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.6", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 0.12" + } + }, + "node_modules/form-data-encoder": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz", + "integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==", + "engines": { + "node": ">= 14.17" + } + }, + "node_modules/fp-and-or": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/fp-and-or/-/fp-and-or-0.1.4.tgz", + "integrity": "sha512-+yRYRhpnFPWXSly/6V4Lw9IfOV26uu30kynGJ03PW+MnjOEQe45RZ141QcS0aJehYBYA50GfCDnsRbFJdhssRw==", + "engines": { + "node": ">=10" + } + }, + "node_modules/fs-minipass": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz", + "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/fs-minipass/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gauge": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz", + "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==", + "dependencies": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.3", + "console-control-strings": "^1.1.0", + "has-unicode": "^2.0.1", + "signal-exit": "^3.0.7", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.5" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/gauge/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/gauge/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/get-stdin": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-8.0.0.tgz", + "integrity": "sha512-sY22aA6xchAzprjyqmSEQv4UbAAzRN0L2dQB0NlN5acTTK9Don6nhoc3eAbUnpZiCANAMfd/+40kVdKfFygohg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==", + "dependencies": { + "assert-plus": "^1.0.0" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", + "dev": true + }, + "node_modules/global-dirs": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz", + "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==", + "dependencies": { + "ini": "2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/global-dirs/node_modules/ini": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz", + "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/got": { + "version": "12.6.1", + "resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz", + "integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==", + "dependencies": { + "@sindresorhus/is": "^5.2.0", + "@szmarczak/http-timer": "^5.0.1", + "cacheable-lookup": "^7.0.0", + "cacheable-request": "^10.2.8", + "decompress-response": "^6.0.0", + "form-data-encoder": "^2.1.2", + "get-stream": "^6.0.1", + "http2-wrapper": "^2.1.10", + "lowercase-keys": "^3.0.0", + "p-cancelable": "^3.0.0", + "responselike": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" + }, + "node_modules/har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==", + "engines": { + "node": ">=4" + } + }, + "node_modules/har-validator": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", + "deprecated": "this library is no longer supported", + "dependencies": { + "ajv": "^6.12.3", + "har-schema": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==" + }, + "node_modules/has-yarn": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz", + "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hosted-git-info": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-5.2.1.tgz", + "integrity": "sha512-xIcQYMnhcx2Nr4JTjsFmwwnr9vldugPy9uVm0o87bjqqWMv9GaqsTeT+i99wTl0mk1uLxJtHxLb8kymqTENQsw==", + "dependencies": { + "lru-cache": "^7.5.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/hosted-git-info/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/htmlparser2": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.10.1.tgz", + "integrity": "sha512-IgieNijUMbkDovyoKObU1DUhm1iwNYE/fuifEoEHfd1oZKZDaONBSkal7Y01shxsM49R4XaMdGez3WnF9UfiCQ==", + "dependencies": { + "domelementtype": "^1.3.1", + "domhandler": "^2.3.0", + "domutils": "^1.5.1", + "entities": "^1.1.1", + "inherits": "^2.0.1", + "readable-stream": "^3.1.1" + } + }, + "node_modules/htmlparser2/node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/htmlparser2/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/htmlparser2/node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/http-cache-semantics": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz", + "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==" + }, + "node_modules/http-proxy-agent": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz", + "integrity": "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==", + "dependencies": { + "@tootallnate/once": "2", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/http-proxy-agent/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/http-proxy-agent/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==", + "dependencies": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + }, + "engines": { + "node": ">=0.8", + "npm": ">=1.3.7" + } + }, + "node_modules/http2-wrapper": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz", + "integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.2.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, + "node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/https-proxy-agent/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/https-proxy-agent/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "dependencies": { + "ms": "^2.0.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "optional": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ignore": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz", + "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==", + "engines": { + "node": ">= 4" + } + }, + "node_modules/ignore-walk": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-6.0.4.tgz", + "integrity": "sha512-t7sv42WkwFkyKbivUCglsQW5YWMskWtbEf4MNKX5u/CCWHKSPzN4FtBQGsQZgCLbxOzpVlcbWVK5KB3auIOjSw==", + "dependencies": { + "minimatch": "^9.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/ignore-walk/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/ignore-walk/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/import-lazy": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz", + "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-local/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/import-local/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/import-local/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-local/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/import-local/node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/import-local/node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/import-local/node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/infer-owner": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz", + "integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==" + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/interpret": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-3.1.1.tgz", + "integrity": "sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==", + "dev": true, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/ip-address": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz", + "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==", + "dependencies": { + "jsbn": "1.1.0", + "sprintf-js": "^1.1.3" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/ip-address/node_modules/jsbn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz", + "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==" + }, + "node_modules/is-ci": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz", + "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==", + "dependencies": { + "ci-info": "^3.2.0" + }, + "bin": { + "is-ci": "bin.js" + } + }, + "node_modules/is-core-module": { + "version": "2.13.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.1.tgz", + "integrity": "sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==", + "dependencies": { + "hasown": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-installed-globally": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz", + "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==", + "dependencies": { + "global-dirs": "^3.0.0", + "is-path-inside": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-lambda": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", + "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==" + }, + "node_modules/is-npm": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-6.0.0.tgz", + "integrity": "sha512-JEjxbSmtPSt1c8XTkVrlujcXdKV1/tvuQ7GwKcAlyiVLeYFQ2VHat8xfrDJsIkhCdF/tZ7CiIR3sy141c6+gPQ==", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-obj": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz", + "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "dev": true, + "dependencies": { + "isobject": "^3.0.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "node_modules/is-yarn-global": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.4.1.tgz", + "integrity": "sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==", + "engines": { + "node": ">=12" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + }, + "node_modules/isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "node_modules/jackspeak": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.6.tgz", + "integrity": "sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/jest-worker": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", + "dev": true, + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/jju": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/jju/-/jju-1.4.0.tgz", + "integrity": "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==" + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==" + }, + "node_modules/json-parse-even-better-errors": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.1.tgz", + "integrity": "sha512-aatBvbL26wVUCLmbWdCpeu9iF5wOyWpagiKkInA+kfws3sWdBrTnsvN2CKcyCYyUrc7rebNBlK6+kteg7ksecg==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/json-parse-helpfulerror": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/json-parse-helpfulerror/-/json-parse-helpfulerror-1.0.3.tgz", + "integrity": "sha512-XgP0FGR77+QhUxjXkwOMkC94k3WtqEBfcnjWqhRd82qTat4SWKRE+9kUnynz/shm3I4ea2+qISvTIeGTNU7kJg==", + "dependencies": { + "jju": "^1.1.0" + } + }, + "node_modules/json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonlines": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsonlines/-/jsonlines-0.1.1.tgz", + "integrity": "sha512-ekDrAGso79Cvf+dtm+mL8OBI2bmAOt3gssYs833De/C9NmIpWDWyUO4zPgB5x2/OhY366dkhgfPMYfwZF7yOZA==" + }, + "node_modules/jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", + "engines": [ + "node >= 0.2.0" + ] + }, + "node_modules/jsprim": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz", + "integrity": "sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==", + "dependencies": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.4.0", + "verror": "1.10.0" + }, + "engines": { + "node": ">=0.6.0" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/kleur": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", + "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/latest-version": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-7.0.0.tgz", + "integrity": "sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==", + "dependencies": { + "package-json": "^8.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/loader-runner": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz", + "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==", + "dev": true, + "engines": { + "node": ">=6.11.5" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" + }, + "node_modules/lodash.assignin": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assignin/-/lodash.assignin-4.2.0.tgz", + "integrity": "sha512-yX/rx6d/UTVh7sSVWVSIMjfnz95evAgDFdb1ZozC35I9mSFCkmzptOzevxjgbQUsc78NR44LVHWjsoMQXy9FDg==" + }, + "node_modules/lodash.bind": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/lodash.bind/-/lodash.bind-4.2.1.tgz", + "integrity": "sha512-lxdsn7xxlCymgLYo1gGvVrfHmkjDiyqVv62FAeF2i5ta72BipE1SLxw8hPEPLhD4/247Ijw07UQH7Hq/chT5LA==" + }, + "node_modules/lodash.defaults": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", + "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==" + }, + "node_modules/lodash.filter": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.filter/-/lodash.filter-4.6.0.tgz", + "integrity": "sha512-pXYUy7PR8BCLwX5mgJ/aNtyOvuJTdZAo9EQFUvMIYugqmJxnrYaANvTbgndOzHSCSR0wnlBBfRXJL5SbWxo3FQ==" + }, + "node_modules/lodash.flatten": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz", + "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==" + }, + "node_modules/lodash.foreach": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.foreach/-/lodash.foreach-4.5.0.tgz", + "integrity": "sha512-aEXTF4d+m05rVOAUG3z4vZZ4xVexLKZGF0lIxuHZ1Hplpk/3B6Z1+/ICICYRLm7c41Z2xiejbkCkJoTlypoXhQ==" + }, + "node_modules/lodash.map": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.map/-/lodash.map-4.6.0.tgz", + "integrity": "sha512-worNHGKLDetmcEYDvh2stPCrrQRkP20E4l0iIS7F8EvzMqBBi7ltvFN5m1HvTf1P7Jk1txKhvFcmYsCr8O2F1Q==" + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==" + }, + "node_modules/lodash.pick": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz", + "integrity": "sha512-hXt6Ul/5yWjfklSGvLQl8vM//l3FtyHZeuelpzK6mm99pNvN9yTDruNZPEJZD1oWrqo+izBmB7oUfWgcCX7s4Q==" + }, + "node_modules/lodash.reduce": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reduce/-/lodash.reduce-4.6.0.tgz", + "integrity": "sha512-6raRe2vxCYBhpBu+B+TtNGUzah+hQjVdu3E17wfusjyrXBka2nBS8OH/gjVZ5PvHOhWmIZTYri09Z6n/QfnNMw==" + }, + "node_modules/lodash.reject": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reject/-/lodash.reject-4.6.0.tgz", + "integrity": "sha512-qkTuvgEzYdyhiJBx42YPzPo71R1aEr0z79kAv7Ixg8wPFEjgRgJdUsGMG3Hf3OYSF/kHI79XhNlt+5Ar6OzwxQ==" + }, + "node_modules/lodash.some": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz", + "integrity": "sha512-j7MJE+TuT51q9ggt4fSgVqro163BEFjAt3u97IqU+JA2DkWl80nFTrowzLpZ/BnpN7rrl0JA/593NAdd8p/scQ==" + }, + "node_modules/lowercase-keys": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz", + "integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/make-fetch-happen": { + "version": "11.1.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-11.1.1.tgz", + "integrity": "sha512-rLWS7GCSTcEujjVBs2YqG7Y4643u8ucvCJeSRqiLYhesrDuzeuFIk37xREzAsfQaqzl8b9rNCE4m6J8tvX4Q8w==", + "dependencies": { + "agentkeepalive": "^4.2.1", + "cacache": "^17.0.0", + "http-cache-semantics": "^4.1.1", + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "is-lambda": "^1.0.1", + "lru-cache": "^7.7.1", + "minipass": "^5.0.0", + "minipass-fetch": "^3.0.0", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "socks-proxy-agent": "^7.0.0", + "ssri": "^10.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/cacache": { + "version": "17.1.4", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.1.4.tgz", + "integrity": "sha512-/aJwG2l3ZMJ1xNAnqbMpA40of9dj/pIH3QfiuQSqjfPJF747VR0J/bHn+/KdNnHKc6XQcWt/AfRSBft82W1d2A==", + "dependencies": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^7.7.1", + "minipass": "^7.0.3", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/cacache/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/make-fetch-happen/node_modules/glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/make-fetch-happen/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/make-fetch-happen/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/make-fetch-happen/node_modules/ssri": { + "version": "10.0.5", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.5.tgz", + "integrity": "sha512-bSf16tAFkGeRlUNDjXu8FzaMQt6g2HZJrun7mtMbIPOddxt3GLMSz5VWUWcqTJUPfLEaDIepGxv+bYQW49596A==", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/ssri/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/make-fetch-happen/node_modules/unique-filename": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", + "dependencies": { + "unique-slug": "^4.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/unique-slug": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-response": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz", + "integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", + "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-collect": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", + "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minipass-collect/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-collect/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/minipass-fetch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.4.tgz", + "integrity": "sha512-jHAqnA728uUpIaFm7NWsCnqKT6UqZz7GcI/bDpPATuwYyKwJwW0remxSCxUlKiEty+eopHGa3oc8WxgQ1FFJqg==", + "dependencies": { + "minipass": "^7.0.3", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + }, + "optionalDependencies": { + "encoding": "^0.1.13" + } + }, + "node_modules/minipass-fetch/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minipass-flush/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-flush/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/minipass-json-stream": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minipass-json-stream/-/minipass-json-stream-1.0.1.tgz", + "integrity": "sha512-ODqY18UZt/I8k+b7rl2AENgbWE8IDYam+undIJONvigAz8KR5GWblsFTEfQs0WODsjbSXWlm+JHEv8Gr6Tfdbg==", + "dependencies": { + "jsonparse": "^1.3.1", + "minipass": "^3.0.0" + } + }, + "node_modules/minipass-json-stream/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-json-stream/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-pipeline/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-pipeline/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/minipass-sized": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz", + "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-sized/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-sized/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "dependencies": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minizlib/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minizlib/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "node_modules/ncu": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/ncu/-/ncu-0.2.1.tgz", + "integrity": "sha512-uEOi3lTWbpR2ScjGbg3gRfmIMQjdGh/15bXUBC7MBcUkf4TbB+ozIDWBfpGnEhDUs7lFTYMDERBHFssD2HJM4A==", + "deprecated": "This package has been deprecated, and this is not npm-check-updates", + "dependencies": { + "cheerio": "^0.22.0", + "request": "^2.79.0" + }, + "bin": { + "ncu": "cli.js", + "ncu-weather": "cli.js" + } + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true + }, + "node_modules/node-gyp": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-9.4.1.tgz", + "integrity": "sha512-OQkWKbjQKbGkMf/xqI1jjy3oCTgMKJac58G2+bjZb3fza6gW2YrCSdMQYaoTb70crvE//Gngr4f0AgVHmqHvBQ==", + "dependencies": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^7.1.4", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^10.0.3", + "nopt": "^6.0.0", + "npmlog": "^6.0.0", + "rimraf": "^3.0.2", + "semver": "^7.3.5", + "tar": "^6.1.2", + "which": "^2.0.2" + }, + "bin": { + "node-gyp": "bin/node-gyp.js" + }, + "engines": { + "node": "^12.13 || ^14.13 || >=16" + } + }, + "node_modules/node-gyp/node_modules/@npmcli/fs": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-2.1.2.tgz", + "integrity": "sha512-yOJKRvohFOaLqipNtwYB9WugyZKhC/DZC4VYPmpaCzDBrA8YpK3qHZ8/HGscMnE4GqbkLNuVcCnxkeQEdGt6LQ==", + "dependencies": { + "@gar/promisify": "^1.1.3", + "semver": "^7.3.5" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/node-gyp/node_modules/cacache": { + "version": "16.1.3", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.1.3.tgz", + "integrity": "sha512-/+Emcj9DAXxX4cwlLmRI9c166RuL3w30zp4R7Joiv2cQTtTtA+jeuCAjH3ZlGnYS3tKENSrKhAzVVP9GVyzeYQ==", + "dependencies": { + "@npmcli/fs": "^2.1.0", + "@npmcli/move-file": "^2.0.0", + "chownr": "^2.0.0", + "fs-minipass": "^2.1.0", + "glob": "^8.0.1", + "infer-owner": "^1.0.4", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "mkdirp": "^1.0.4", + "p-map": "^4.0.0", + "promise-inflight": "^1.0.1", + "rimraf": "^3.0.2", + "ssri": "^9.0.0", + "tar": "^6.1.11", + "unique-filename": "^2.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/cacache/node_modules/glob": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz", + "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^5.0.1", + "once": "^1.3.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/node-gyp/node_modules/chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "engines": { + "node": ">=10" + } + }, + "node_modules/node-gyp/node_modules/fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/node-gyp/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/node-gyp/node_modules/make-fetch-happen": { + "version": "10.2.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz", + "integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==", + "dependencies": { + "agentkeepalive": "^4.2.1", + "cacache": "^16.1.0", + "http-cache-semantics": "^4.1.0", + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "is-lambda": "^1.0.1", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-fetch": "^2.0.3", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "socks-proxy-agent": "^7.0.0", + "ssri": "^9.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/minimatch": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz", + "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-gyp/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/node-gyp/node_modules/minipass-fetch": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-2.1.2.tgz", + "integrity": "sha512-LT49Zi2/WMROHYoqGgdlQIZh8mLPZmOrN2NdJjMXxYe4nkN6FUyuPuOAOedNJDrx0IRGg9+4guZewtp8hE6TxA==", + "dependencies": { + "minipass": "^3.1.6", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "optionalDependencies": { + "encoding": "^0.1.13" + } + }, + "node_modules/node-gyp/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-gyp/node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/node-gyp/node_modules/ssri": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-9.0.1.tgz", + "integrity": "sha512-o57Wcn66jMQvfHG1FlYbWeZWW/dHZhJXjpIcTfXldXEk5nz5lStPo3mK0OJQfGR3RbZUlbISexbljkJzuEj/8Q==", + "dependencies": { + "minipass": "^3.1.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/unique-filename": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-2.0.1.tgz", + "integrity": "sha512-ODWHtkkdx3IAR+veKxFV+VBkUMcN+FaqzUUd7IZzt+0zhDZFPFxhlqwPF3YQvMHx1TD0tdgYl+kuPnJ8E6ql7A==", + "dependencies": { + "unique-slug": "^3.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/unique-slug": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-3.0.0.tgz", + "integrity": "sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/node-gyp/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/node-releases": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==", + "dev": true + }, + "node_modules/nopt": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-6.0.0.tgz", + "integrity": "sha512-ZwLpbTgdhuZUnZzjd7nb1ZV+4DoiC6/sfiVKok72ym/4Tlf+DFdlHYmT2JPmcNNWV6Pi3SDf1kT+A4r9RTuT9g==", + "dependencies": { + "abbrev": "^1.0.0" + }, + "bin": { + "nopt": "bin/nopt.js" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/normalize-package-data": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-5.0.0.tgz", + "integrity": "sha512-h9iPVIfrVZ9wVYQnxFgtw1ugSvGEMOlyPWWtm8BMJhnwyEL/FLbYbTY3V3PpjI/BUK67n9PEWDu6eHzu1fB15Q==", + "dependencies": { + "hosted-git-info": "^6.0.0", + "is-core-module": "^2.8.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/normalize-package-data/node_modules/hosted-git-info": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-6.1.1.tgz", + "integrity": "sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==", + "dependencies": { + "lru-cache": "^7.5.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/normalize-package-data/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/normalize-url": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.1.tgz", + "integrity": "sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm": { + "version": "10.5.2", + "resolved": "https://registry.npmjs.org/npm/-/npm-10.5.2.tgz", + "integrity": "sha512-cHVG7QEJwJdZyOrK0dKX5uf3R5Fd0E8AcmSES1jLtO52UT1enUKZ96Onw/xwq4CbrTZEnDuu2Vf9kCQh/Sd12w==", + "bundleDependencies": [ + "@isaacs/string-locale-compare", + "@npmcli/arborist", + "@npmcli/config", + "@npmcli/fs", + "@npmcli/map-workspaces", + "@npmcli/package-json", + "@npmcli/promise-spawn", + "@npmcli/redact", + "@npmcli/run-script", + "@sigstore/tuf", + "abbrev", + "archy", + "cacache", + "chalk", + "ci-info", + "cli-columns", + "cli-table3", + "columnify", + "fastest-levenshtein", + "fs-minipass", + "glob", + "graceful-fs", + "hosted-git-info", + "ini", + "init-package-json", + "is-cidr", + "json-parse-even-better-errors", + "libnpmaccess", + "libnpmdiff", + "libnpmexec", + "libnpmfund", + "libnpmhook", + "libnpmorg", + "libnpmpack", + "libnpmpublish", + "libnpmsearch", + "libnpmteam", + "libnpmversion", + "make-fetch-happen", + "minimatch", + "minipass", + "minipass-pipeline", + "ms", + "node-gyp", + "nopt", + "normalize-package-data", + "npm-audit-report", + "npm-install-checks", + "npm-package-arg", + "npm-pick-manifest", + "npm-profile", + "npm-registry-fetch", + "npm-user-validate", + "npmlog", + "p-map", + "pacote", + "parse-conflict-json", + "proc-log", + "qrcode-terminal", + "read", + "semver", + "spdx-expression-parse", + "ssri", + "supports-color", + "tar", + "text-table", + "tiny-relative-date", + "treeverse", + "validate-npm-package-name", + "which", + "write-file-atomic" + ], + "dependencies": { + "@isaacs/string-locale-compare": "^1.1.0", + "@npmcli/arborist": "^7.2.1", + "@npmcli/config": "^8.0.2", + "@npmcli/fs": "^3.1.0", + "@npmcli/map-workspaces": "^3.0.6", + "@npmcli/package-json": "^5.0.2", + "@npmcli/promise-spawn": "^7.0.1", + "@npmcli/redact": "^1.1.0", + "@npmcli/run-script": "^7.0.4", + "@sigstore/tuf": "^2.3.2", + "abbrev": "^2.0.0", + "archy": "~1.0.0", + "cacache": "^18.0.2", + "chalk": "^5.3.0", + "ci-info": "^4.0.0", + "cli-columns": "^4.0.0", + "cli-table3": "^0.6.4", + "columnify": "^1.6.0", + "fastest-levenshtein": "^1.0.16", + "fs-minipass": "^3.0.3", + "glob": "^10.3.12", + "graceful-fs": "^4.2.11", + "hosted-git-info": "^7.0.1", + "ini": "^4.1.2", + "init-package-json": "^6.0.2", + "is-cidr": "^5.0.5", + "json-parse-even-better-errors": "^3.0.1", + "libnpmaccess": "^8.0.1", + "libnpmdiff": "^6.0.3", + "libnpmexec": "^7.0.4", + "libnpmfund": "^5.0.1", + "libnpmhook": "^10.0.0", + "libnpmorg": "^6.0.1", + "libnpmpack": "^6.0.3", + "libnpmpublish": "^9.0.2", + "libnpmsearch": "^7.0.0", + "libnpmteam": "^6.0.0", + "libnpmversion": "^5.0.1", + "make-fetch-happen": "^13.0.0", + "minimatch": "^9.0.4", + "minipass": "^7.0.4", + "minipass-pipeline": "^1.2.4", + "ms": "^2.1.2", + "node-gyp": "^10.1.0", + "nopt": "^7.2.0", + "normalize-package-data": "^6.0.0", + "npm-audit-report": "^5.0.0", + "npm-install-checks": "^6.3.0", + "npm-package-arg": "^11.0.1", + "npm-pick-manifest": "^9.0.0", + "npm-profile": "^9.0.0", + "npm-registry-fetch": "^16.2.0", + "npm-user-validate": "^2.0.0", + "npmlog": "^7.0.1", + "p-map": "^4.0.0", + "pacote": "^17.0.6", + "parse-conflict-json": "^3.0.1", + "proc-log": "^3.0.0", + "qrcode-terminal": "^0.12.0", + "read": "^3.0.1", + "semver": "^7.6.0", + "spdx-expression-parse": "^4.0.0", + "ssri": "^10.0.5", + "supports-color": "^9.4.0", + "tar": "^6.2.1", + "text-table": "~0.2.0", + "tiny-relative-date": "^1.3.0", + "treeverse": "^3.0.0", + "validate-npm-package-name": "^5.0.0", + "which": "^4.0.0", + "write-file-atomic": "^5.0.1" + }, + "bin": { + "npm": "bin/npm-cli.js", + "npx": "bin/npx-cli.js" + }, + "engines": { + "node": "^18.17.0 || >=20.5.0" + } + }, + "node_modules/npm-bundled": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-3.0.0.tgz", + "integrity": "sha512-Vq0eyEQy+elFpzsKjMss9kxqb9tG3YHg4dsyWuUENuzvSUWe1TCnW/vV9FkhvBk/brEDoDiVd+M1Btosa6ImdQ==", + "dependencies": { + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-check-updates": { + "version": "16.14.17", + "resolved": "https://registry.npmjs.org/npm-check-updates/-/npm-check-updates-16.14.17.tgz", + "integrity": "sha512-ElnDdXKe60f8S6RhzFeaGuH2TFJmt2cU2HjLdowldabdm27nWFCxV2ebeP3xGbQkzp2+RPDQNdW9HqU1lcY8ag==", + "dependencies": { + "chalk": "^5.3.0", + "cli-table3": "^0.6.3", + "commander": "^10.0.1", + "fast-memoize": "^2.5.2", + "find-up": "5.0.0", + "fp-and-or": "^0.1.4", + "get-stdin": "^8.0.0", + "globby": "^11.0.4", + "hosted-git-info": "^5.1.0", + "ini": "^4.1.1", + "js-yaml": "^4.1.0", + "json-parse-helpfulerror": "^1.0.3", + "jsonlines": "^0.1.1", + "lodash": "^4.17.21", + "make-fetch-happen": "^11.1.1", + "minimatch": "^9.0.3", + "p-map": "^4.0.0", + "pacote": "15.2.0", + "parse-github-url": "^1.0.2", + "progress": "^2.0.3", + "prompts-ncu": "^3.0.0", + "rc-config-loader": "^4.1.3", + "remote-git-tags": "^3.0.0", + "rimraf": "^5.0.5", + "semver": "^7.5.4", + "semver-utils": "^1.1.4", + "source-map-support": "^0.5.21", + "spawn-please": "^2.0.2", + "strip-ansi": "^7.1.0", + "strip-json-comments": "^5.0.1", + "untildify": "^4.0.0", + "update-notifier": "^6.0.2" + }, + "bin": { + "ncu": "build/src/bin/cli.js", + "npm-check-updates": "build/src/bin/cli.js" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/npm-check-updates/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/npm-check-updates/node_modules/commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "engines": { + "node": ">=14" + } + }, + "node_modules/npm-check-updates/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-check-updates/node_modules/glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm-check-updates/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-check-updates/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm-check-updates/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-check-updates/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-check-updates/node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm-check-updates/node_modules/rimraf": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-5.0.5.tgz", + "integrity": "sha512-CqDakW+hMe/Bz202FPEymy68P+G50RfMQK+Qo5YUqc9SPipvbGjCGKd0RSKEelbsfQuw3g5NZDSrlZZAJurH1A==", + "dependencies": { + "glob": "^10.3.7" + }, + "bin": { + "rimraf": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm-install-checks": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-6.3.0.tgz", + "integrity": "sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==", + "dependencies": { + "semver": "^7.1.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-normalize-package-bin": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-3.0.1.tgz", + "integrity": "sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-package-arg": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-10.1.0.tgz", + "integrity": "sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==", + "dependencies": { + "hosted-git-info": "^6.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "validate-npm-package-name": "^5.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-package-arg/node_modules/hosted-git-info": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-6.1.1.tgz", + "integrity": "sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==", + "dependencies": { + "lru-cache": "^7.5.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-package-arg/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/npm-packlist": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-7.0.4.tgz", + "integrity": "sha512-d6RGEuRrNS5/N84iglPivjaJPxhDbZmlbTwTDX2IbcRHG5bZCdtysYMhwiPvcF4GisXHGn7xsxv+GQ7T/02M5Q==", + "dependencies": { + "ignore-walk": "^6.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-pick-manifest": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-8.0.2.tgz", + "integrity": "sha512-1dKY+86/AIiq1tkKVD3l0WI+Gd3vkknVGAggsFeBkTvbhMQ1OND/LKkYv4JtXPKUJ8bOTCyLiqEg2P6QNdK+Gg==", + "dependencies": { + "npm-install-checks": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "npm-package-arg": "^10.0.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-registry-fetch": { + "version": "14.0.5", + "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-14.0.5.tgz", + "integrity": "sha512-kIDMIo4aBm6xg7jOttupWZamsZRkAqMqwqqbVXnUqstY5+tapvv6bkH/qMR76jdgV+YljEUCyWx3hRYMrJiAgA==", + "dependencies": { + "make-fetch-happen": "^11.0.0", + "minipass": "^5.0.0", + "minipass-fetch": "^3.0.0", + "minipass-json-stream": "^1.0.1", + "minizlib": "^2.1.2", + "npm-package-arg": "^10.0.0", + "proc-log": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@colors/colors": { + "version": "1.5.0", + "inBundle": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/npm/node_modules/@isaacs/cliui": { + "version": "8.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/npm/node_modules/@isaacs/cliui/node_modules/ansi-regex": { + "version": "6.0.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/npm/node_modules/@isaacs/cliui/node_modules/emoji-regex": { + "version": "9.2.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "inBundle": true, + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/@isaacs/cliui/node_modules/strip-ansi": { + "version": "7.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/npm/node_modules/@isaacs/string-locale-compare": { + "version": "1.1.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/@npmcli/agent": { + "version": "2.2.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "agent-base": "^7.1.0", + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.1", + "lru-cache": "^10.0.1", + "socks-proxy-agent": "^8.0.3" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/arborist": { + "version": "7.4.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@isaacs/string-locale-compare": "^1.1.0", + "@npmcli/fs": "^3.1.0", + "@npmcli/installed-package-contents": "^2.0.2", + "@npmcli/map-workspaces": "^3.0.2", + "@npmcli/metavuln-calculator": "^7.0.0", + "@npmcli/name-from-folder": "^2.0.0", + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.0.0", + "@npmcli/query": "^3.1.0", + "@npmcli/redact": "^1.1.0", + "@npmcli/run-script": "^7.0.2", + "bin-links": "^4.0.1", + "cacache": "^18.0.0", + "common-ancestor-path": "^1.0.1", + "hosted-git-info": "^7.0.1", + "json-parse-even-better-errors": "^3.0.0", + "json-stringify-nice": "^1.1.4", + "minimatch": "^9.0.4", + "nopt": "^7.0.0", + "npm-install-checks": "^6.2.0", + "npm-package-arg": "^11.0.1", + "npm-pick-manifest": "^9.0.0", + "npm-registry-fetch": "^16.2.0", + "npmlog": "^7.0.1", + "pacote": "^17.0.4", + "parse-conflict-json": "^3.0.0", + "proc-log": "^3.0.0", + "promise-all-reject-late": "^1.0.0", + "promise-call-limit": "^3.0.1", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.7", + "ssri": "^10.0.5", + "treeverse": "^3.0.0", + "walk-up-path": "^3.0.1" + }, + "bin": { + "arborist": "bin/index.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/config": { + "version": "8.2.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/map-workspaces": "^3.0.2", + "ci-info": "^4.0.0", + "ini": "^4.1.2", + "nopt": "^7.0.0", + "proc-log": "^3.0.0", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.5", + "walk-up-path": "^3.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/disparity-colors": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "ansi-styles": "^4.3.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/disparity-colors/node_modules/ansi-styles": { + "version": "4.3.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/npm/node_modules/@npmcli/fs": { + "version": "3.1.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/git": { + "version": "5.0.5", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/promise-spawn": "^7.0.0", + "lru-cache": "^10.0.1", + "npm-pick-manifest": "^9.0.0", + "proc-log": "^3.0.0", + "promise-inflight": "^1.0.1", + "promise-retry": "^2.0.1", + "semver": "^7.3.5", + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/installed-package-contents": { + "version": "2.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-bundled": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "bin": { + "installed-package-contents": "lib/index.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/map-workspaces": { + "version": "3.0.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/name-from-folder": "^2.0.0", + "glob": "^10.2.2", + "minimatch": "^9.0.0", + "read-package-json-fast": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/metavuln-calculator": { + "version": "7.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "cacache": "^18.0.0", + "json-parse-even-better-errors": "^3.0.0", + "pacote": "^17.0.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/name-from-folder": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/node-gyp": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/package-json": { + "version": "5.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/git": "^5.0.0", + "glob": "^10.2.2", + "hosted-git-info": "^7.0.0", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^6.0.0", + "proc-log": "^3.0.0", + "semver": "^7.5.3" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/promise-spawn": { + "version": "7.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/query": { + "version": "3.1.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/redact": { + "version": "1.1.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@npmcli/run-script": { + "version": "7.0.4", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.0.0", + "@npmcli/promise-spawn": "^7.0.0", + "node-gyp": "^10.0.0", + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "inBundle": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/npm/node_modules/@sigstore/bundle": { + "version": "2.3.1", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "@sigstore/protobuf-specs": "^0.3.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@sigstore/core": { + "version": "1.1.0", + "inBundle": true, + "license": "Apache-2.0", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@sigstore/protobuf-specs": { + "version": "0.3.1", + "inBundle": true, + "license": "Apache-2.0", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@sigstore/sign": { + "version": "2.3.0", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.0", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.1", + "make-fetch-happen": "^13.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@sigstore/tuf": { + "version": "2.3.2", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "@sigstore/protobuf-specs": "^0.3.0", + "tuf-js": "^2.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@sigstore/verify": { + "version": "1.2.0", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.1", + "@sigstore/core": "^1.1.0", + "@sigstore/protobuf-specs": "^0.3.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@tufjs/canonical-json": { + "version": "2.0.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/@tufjs/models": { + "version": "2.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "@tufjs/canonical-json": "2.0.0", + "minimatch": "^9.0.3" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/abbrev": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/agent-base": { + "version": "7.1.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/npm/node_modules/aggregate-error": { + "version": "3.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/ansi-regex": { + "version": "5.0.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/ansi-styles": { + "version": "6.2.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/npm/node_modules/aproba": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/archy": { + "version": "1.0.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/are-we-there-yet": { + "version": "4.0.2", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/balanced-match": { + "version": "1.0.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/bin-links": { + "version": "4.0.3", + "inBundle": true, + "license": "ISC", + "dependencies": { + "cmd-shim": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "read-cmd-shim": "^4.0.0", + "write-file-atomic": "^5.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/binary-extensions": { + "version": "2.3.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/brace-expansion": { + "version": "2.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/npm/node_modules/builtins": { + "version": "5.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "semver": "^7.0.0" + } + }, + "node_modules/npm/node_modules/cacache": { + "version": "18.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^10.0.1", + "minipass": "^7.0.3", + "minipass-collect": "^2.0.1", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/chalk": { + "version": "5.3.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/npm/node_modules/chownr": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/ci-info": { + "version": "4.0.0", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/cidr-regex": { + "version": "4.0.5", + "inBundle": true, + "license": "BSD-2-Clause", + "dependencies": { + "ip-regex": "^5.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/npm/node_modules/clean-stack": { + "version": "2.2.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/npm/node_modules/cli-columns": { + "version": "4.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/npm/node_modules/cli-table3": { + "version": "0.6.4", + "inBundle": true, + "license": "MIT", + "dependencies": { + "string-width": "^4.2.0" + }, + "engines": { + "node": "10.* || >= 12.*" + }, + "optionalDependencies": { + "@colors/colors": "1.5.0" + } + }, + "node_modules/npm/node_modules/clone": { + "version": "1.0.4", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/npm/node_modules/cmd-shim": { + "version": "6.0.2", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/color-convert": { + "version": "2.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/npm/node_modules/color-name": { + "version": "1.1.4", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/color-support": { + "version": "1.1.3", + "inBundle": true, + "license": "ISC", + "bin": { + "color-support": "bin.js" + } + }, + "node_modules/npm/node_modules/columnify": { + "version": "1.6.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "strip-ansi": "^6.0.1", + "wcwidth": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/npm/node_modules/common-ancestor-path": { + "version": "1.0.1", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/console-control-strings": { + "version": "1.1.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/cross-spawn": { + "version": "7.0.3", + "inBundle": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/npm/node_modules/cross-spawn/node_modules/which": { + "version": "2.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/npm/node_modules/cssesc": { + "version": "3.0.0", + "inBundle": true, + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/npm/node_modules/debug": { + "version": "4.3.4", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/npm/node_modules/debug/node_modules/ms": { + "version": "2.1.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/defaults": { + "version": "1.0.4", + "inBundle": true, + "license": "MIT", + "dependencies": { + "clone": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/diff": { + "version": "5.2.0", + "inBundle": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/npm/node_modules/eastasianwidth": { + "version": "0.2.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/emoji-regex": { + "version": "8.0.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/encoding": { + "version": "0.1.13", + "inBundle": true, + "license": "MIT", + "optional": true, + "dependencies": { + "iconv-lite": "^0.6.2" + } + }, + "node_modules/npm/node_modules/env-paths": { + "version": "2.2.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/npm/node_modules/err-code": { + "version": "2.0.3", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/exponential-backoff": { + "version": "3.1.1", + "inBundle": true, + "license": "Apache-2.0" + }, + "node_modules/npm/node_modules/fastest-levenshtein": { + "version": "1.0.16", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">= 4.9.1" + } + }, + "node_modules/npm/node_modules/foreground-child": { + "version": "3.1.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/fs-minipass": { + "version": "3.0.3", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/function-bind": { + "version": "1.1.2", + "inBundle": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/npm/node_modules/gauge": { + "version": "5.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.3", + "console-control-strings": "^1.1.0", + "has-unicode": "^2.0.1", + "signal-exit": "^4.0.1", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.5" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/glob": { + "version": "10.3.12", + "inBundle": true, + "license": "ISC", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.6", + "minimatch": "^9.0.1", + "minipass": "^7.0.4", + "path-scurry": "^1.10.2" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/graceful-fs": { + "version": "4.2.11", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/has-unicode": { + "version": "2.0.1", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/hasown": { + "version": "2.0.2", + "inBundle": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/npm/node_modules/hosted-git-info": { + "version": "7.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^10.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/http-cache-semantics": { + "version": "4.1.1", + "inBundle": true, + "license": "BSD-2-Clause" + }, + "node_modules/npm/node_modules/http-proxy-agent": { + "version": "7.0.2", + "inBundle": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/npm/node_modules/https-proxy-agent": { + "version": "7.0.4", + "inBundle": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.0.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/npm/node_modules/iconv-lite": { + "version": "0.6.3", + "inBundle": true, + "license": "MIT", + "optional": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/npm/node_modules/ignore-walk": { + "version": "6.0.4", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minimatch": "^9.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/imurmurhash": { + "version": "0.1.4", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/npm/node_modules/indent-string": { + "version": "4.0.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/ini": { + "version": "4.1.2", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/init-package-json": { + "version": "6.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/package-json": "^5.0.0", + "npm-package-arg": "^11.0.0", + "promzard": "^1.0.0", + "read": "^3.0.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4", + "validate-npm-package-name": "^5.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/ip-address": { + "version": "9.0.5", + "inBundle": true, + "license": "MIT", + "dependencies": { + "jsbn": "1.1.0", + "sprintf-js": "^1.1.3" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/npm/node_modules/ip-address/node_modules/sprintf-js": { + "version": "1.1.3", + "inBundle": true, + "license": "BSD-3-Clause" + }, + "node_modules/npm/node_modules/ip-regex": { + "version": "5.0.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/is-cidr": { + "version": "5.0.5", + "inBundle": true, + "license": "BSD-2-Clause", + "dependencies": { + "cidr-regex": "^4.0.4" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/npm/node_modules/is-core-module": { + "version": "2.13.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/npm/node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/is-lambda": { + "version": "1.0.1", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/isexe": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/jackspeak": { + "version": "2.3.6", + "inBundle": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/npm/node_modules/jsbn": { + "version": "1.1.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/json-parse-even-better-errors": { + "version": "3.0.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/json-stringify-nice": { + "version": "1.1.4", + "inBundle": true, + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/jsonparse": { + "version": "1.3.1", + "engines": [ + "node >= 0.2.0" + ], + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/just-diff": { + "version": "6.0.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/just-diff-apply": { + "version": "5.5.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/libnpmaccess": { + "version": "8.0.3", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-package-arg": "^11.0.1", + "npm-registry-fetch": "^16.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmdiff": { + "version": "6.0.9", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/disparity-colors": "^3.0.0", + "@npmcli/installed-package-contents": "^2.0.2", + "binary-extensions": "^2.3.0", + "diff": "^5.1.0", + "minimatch": "^9.0.4", + "npm-package-arg": "^11.0.1", + "pacote": "^17.0.4", + "tar": "^6.2.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmexec": { + "version": "7.0.10", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/run-script": "^7.0.2", + "ci-info": "^4.0.0", + "npm-package-arg": "^11.0.1", + "npmlog": "^7.0.1", + "pacote": "^17.0.4", + "proc-log": "^3.0.0", + "read": "^3.0.1", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.7", + "walk-up-path": "^3.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmfund": { + "version": "5.0.7", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/arborist": "^7.2.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmhook": { + "version": "10.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmorg": { + "version": "6.0.3", + "inBundle": true, + "license": "ISC", + "dependencies": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmpack": { + "version": "6.0.9", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/run-script": "^7.0.2", + "npm-package-arg": "^11.0.1", + "pacote": "^17.0.4" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmpublish": { + "version": "9.0.5", + "inBundle": true, + "license": "ISC", + "dependencies": { + "ci-info": "^4.0.0", + "normalize-package-data": "^6.0.0", + "npm-package-arg": "^11.0.1", + "npm-registry-fetch": "^16.2.0", + "proc-log": "^3.0.0", + "semver": "^7.3.7", + "sigstore": "^2.2.0", + "ssri": "^10.0.5" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmsearch": { + "version": "7.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-registry-fetch": "^16.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmteam": { + "version": "6.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/libnpmversion": { + "version": "5.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/git": "^5.0.3", + "@npmcli/run-script": "^7.0.2", + "json-parse-even-better-errors": "^3.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.7" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/lru-cache": { + "version": "10.2.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "14 || >=16.14" + } + }, + "node_modules/npm/node_modules/make-fetch-happen": { + "version": "13.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/agent": "^2.0.0", + "cacache": "^18.0.0", + "http-cache-semantics": "^4.1.1", + "is-lambda": "^1.0.1", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "ssri": "^10.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/minimatch": { + "version": "9.0.4", + "inBundle": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/minipass": { + "version": "7.0.4", + "inBundle": true, + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/npm/node_modules/minipass-collect": { + "version": "2.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/npm/node_modules/minipass-fetch": { + "version": "3.0.4", + "inBundle": true, + "license": "MIT", + "dependencies": { + "minipass": "^7.0.3", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + }, + "optionalDependencies": { + "encoding": "^0.1.13" + } + }, + "node_modules/npm/node_modules/minipass-flush": { + "version": "1.0.5", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/npm/node_modules/minipass-flush/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minipass-json-stream": { + "version": "1.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "jsonparse": "^1.3.1", + "minipass": "^3.0.0" + } + }, + "node_modules/npm/node_modules/minipass-json-stream/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minipass-pipeline": { + "version": "1.2.4", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minipass-pipeline/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minipass-sized": { + "version": "1.0.3", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minipass-sized/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/minizlib": { + "version": "2.1.2", + "inBundle": true, + "license": "MIT", + "dependencies": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/npm/node_modules/minizlib/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/mkdirp": { + "version": "1.0.4", + "inBundle": true, + "license": "MIT", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/ms": { + "version": "2.1.3", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/mute-stream": { + "version": "1.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/negotiator": { + "version": "0.6.3", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/npm/node_modules/node-gyp": { + "version": "10.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^10.3.10", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^13.0.0", + "nopt": "^7.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "tar": "^6.1.2", + "which": "^4.0.0" + }, + "bin": { + "node-gyp": "bin/node-gyp.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/nopt": { + "version": "7.2.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "abbrev": "^2.0.0" + }, + "bin": { + "nopt": "bin/nopt.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/normalize-package-data": { + "version": "6.0.0", + "inBundle": true, + "license": "BSD-2-Clause", + "dependencies": { + "hosted-git-info": "^7.0.0", + "is-core-module": "^2.8.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-audit-report": { + "version": "5.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-bundled": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-install-checks": { + "version": "6.3.0", + "inBundle": true, + "license": "BSD-2-Clause", + "dependencies": { + "semver": "^7.1.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-normalize-package-bin": { + "version": "3.0.1", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-package-arg": { + "version": "11.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "hosted-git-info": "^7.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "validate-npm-package-name": "^5.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-packlist": { + "version": "8.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "ignore-walk": "^6.0.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-pick-manifest": { + "version": "9.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-install-checks": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "npm-package-arg": "^11.0.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-profile": { + "version": "9.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "npm-registry-fetch": "^16.0.0", + "proc-log": "^3.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-registry-fetch": { + "version": "16.2.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/redact": "^1.1.0", + "make-fetch-happen": "^13.0.0", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minipass-json-stream": "^1.0.1", + "minizlib": "^2.1.2", + "npm-package-arg": "^11.0.0", + "proc-log": "^3.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npm-user-validate": { + "version": "2.0.0", + "inBundle": true, + "license": "BSD-2-Clause", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/npmlog": { + "version": "7.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "are-we-there-yet": "^4.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^5.0.0", + "set-blocking": "^2.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/p-map": { + "version": "4.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/pacote": { + "version": "17.0.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "@npmcli/git": "^5.0.0", + "@npmcli/installed-package-contents": "^2.0.1", + "@npmcli/promise-spawn": "^7.0.0", + "@npmcli/run-script": "^7.0.0", + "cacache": "^18.0.0", + "fs-minipass": "^3.0.0", + "minipass": "^7.0.2", + "npm-package-arg": "^11.0.0", + "npm-packlist": "^8.0.0", + "npm-pick-manifest": "^9.0.0", + "npm-registry-fetch": "^16.0.0", + "proc-log": "^3.0.0", + "promise-retry": "^2.0.1", + "read-package-json": "^7.0.0", + "read-package-json-fast": "^3.0.0", + "sigstore": "^2.2.0", + "ssri": "^10.0.0", + "tar": "^6.1.11" + }, + "bin": { + "pacote": "lib/bin.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/parse-conflict-json": { + "version": "3.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "json-parse-even-better-errors": "^3.0.0", + "just-diff": "^6.0.0", + "just-diff-apply": "^5.2.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/path-key": { + "version": "3.1.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/path-scurry": { + "version": "1.10.2", + "inBundle": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/postcss-selector-parser": { + "version": "6.0.16", + "inBundle": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/npm/node_modules/proc-log": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/promise-all-reject-late": { + "version": "1.0.1", + "inBundle": true, + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/promise-call-limit": { + "version": "3.0.1", + "inBundle": true, + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/promise-inflight": { + "version": "1.0.1", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/promise-retry": { + "version": "2.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/promzard": { + "version": "1.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "read": "^3.0.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/qrcode-terminal": { + "version": "0.12.0", + "inBundle": true, + "bin": { + "qrcode-terminal": "bin/qrcode-terminal.js" + } + }, + "node_modules/npm/node_modules/read": { + "version": "3.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "mute-stream": "^1.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/read-cmd-shim": { + "version": "4.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/read-package-json": { + "version": "7.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "glob": "^10.2.2", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/read-package-json-fast": { + "version": "3.0.2", + "inBundle": true, + "license": "ISC", + "dependencies": { + "json-parse-even-better-errors": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/retry": { + "version": "0.12.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/npm/node_modules/safer-buffer": { + "version": "2.1.2", + "inBundle": true, + "license": "MIT", + "optional": true + }, + "node_modules/npm/node_modules/semver": { + "version": "7.6.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/set-blocking": { + "version": "2.0.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/shebang-command": { + "version": "2.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/shebang-regex": { + "version": "3.0.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/signal-exit": { + "version": "4.1.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/npm/node_modules/sigstore": { + "version": "2.3.0", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.1", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.1", + "@sigstore/sign": "^2.3.0", + "@sigstore/tuf": "^2.3.1", + "@sigstore/verify": "^1.2.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/smart-buffer": { + "version": "4.2.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">= 6.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/npm/node_modules/socks": { + "version": "2.8.3", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ip-address": "^9.0.5", + "smart-buffer": "^4.2.0" + }, + "engines": { + "node": ">= 10.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/npm/node_modules/socks-proxy-agent": { + "version": "8.0.3", + "inBundle": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.1", + "debug": "^4.3.4", + "socks": "^2.7.1" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/npm/node_modules/spdx-correct": { + "version": "3.2.0", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/npm/node_modules/spdx-correct/node_modules/spdx-expression-parse": { + "version": "3.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/npm/node_modules/spdx-exceptions": { + "version": "2.5.0", + "inBundle": true, + "license": "CC-BY-3.0" + }, + "node_modules/npm/node_modules/spdx-expression-parse": { + "version": "4.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/npm/node_modules/spdx-license-ids": { + "version": "3.0.17", + "inBundle": true, + "license": "CC0-1.0" + }, + "node_modules/npm/node_modules/ssri": { + "version": "10.0.5", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/string-width": { + "version": "4.2.3", + "inBundle": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "inBundle": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/strip-ansi": { + "version": "6.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/supports-color": { + "version": "9.4.0", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/npm/node_modules/tar": { + "version": "6.2.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/npm/node_modules/tar/node_modules/fs-minipass": { + "version": "2.1.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/npm/node_modules/tar/node_modules/fs-minipass/node_modules/minipass": { + "version": "3.3.6", + "inBundle": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/tar/node_modules/minipass": { + "version": "5.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": ">=8" + } + }, + "node_modules/npm/node_modules/text-table": { + "version": "0.2.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/tiny-relative-date": { + "version": "1.3.0", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/treeverse": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/tuf-js": { + "version": "2.2.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "@tufjs/models": "2.0.0", + "debug": "^4.3.4", + "make-fetch-happen": "^13.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/unique-filename": { + "version": "3.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "unique-slug": "^4.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/unique-slug": { + "version": "4.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/util-deprecate": { + "version": "1.0.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/validate-npm-package-license": { + "version": "3.0.4", + "inBundle": true, + "license": "Apache-2.0", + "dependencies": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "node_modules/npm/node_modules/validate-npm-package-license/node_modules/spdx-expression-parse": { + "version": "3.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/npm/node_modules/validate-npm-package-name": { + "version": "5.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "builtins": "^5.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/walk-up-path": { + "version": "3.0.1", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npm/node_modules/wcwidth": { + "version": "1.0.1", + "inBundle": true, + "license": "MIT", + "dependencies": { + "defaults": "^1.0.3" + } + }, + "node_modules/npm/node_modules/which": { + "version": "4.0.0", + "inBundle": true, + "license": "ISC", + "dependencies": { + "isexe": "^3.1.1" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/which/node_modules/isexe": { + "version": "3.1.1", + "inBundle": true, + "license": "ISC", + "engines": { + "node": ">=16" + } + }, + "node_modules/npm/node_modules/wide-align": { + "version": "1.1.5", + "inBundle": true, + "license": "ISC", + "dependencies": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "node_modules/npm/node_modules/wrap-ansi": { + "version": "8.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/npm/node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/npm/node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/npm/node_modules/wrap-ansi/node_modules/ansi-regex": { + "version": "6.0.1", + "inBundle": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/npm/node_modules/wrap-ansi/node_modules/emoji-regex": { + "version": "9.2.2", + "inBundle": true, + "license": "MIT" + }, + "node_modules/npm/node_modules/wrap-ansi/node_modules/string-width": { + "version": "5.1.2", + "inBundle": true, + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm/node_modules/wrap-ansi/node_modules/strip-ansi": { + "version": "7.1.0", + "inBundle": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/npm/node_modules/write-file-atomic": { + "version": "5.0.1", + "inBundle": true, + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm/node_modules/yallist": { + "version": "4.0.0", + "inBundle": true, + "license": "ISC" + }, + "node_modules/npmlog": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz", + "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==", + "dependencies": { + "are-we-there-yet": "^3.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^4.0.3", + "set-blocking": "^2.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/nth-check": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.2.tgz", + "integrity": "sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==", + "dependencies": { + "boolbase": "~1.0.0" + } + }, + "node_modules/oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==", + "engines": { + "node": "*" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/p-cancelable": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz", + "integrity": "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==", + "engines": { + "node": ">=12.20" + } + }, + "node_modules/p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/package-json": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-8.1.1.tgz", + "integrity": "sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA==", + "dependencies": { + "got": "^12.1.0", + "registry-auth-token": "^5.0.1", + "registry-url": "^6.0.0", + "semver": "^7.3.7" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pacote": { + "version": "15.2.0", + "resolved": "https://registry.npmjs.org/pacote/-/pacote-15.2.0.tgz", + "integrity": "sha512-rJVZeIwHTUta23sIZgEIM62WYwbmGbThdbnkt81ravBplQv+HjyroqnLRNH2+sLJHcGZmLRmhPwACqhfTcOmnA==", + "dependencies": { + "@npmcli/git": "^4.0.0", + "@npmcli/installed-package-contents": "^2.0.1", + "@npmcli/promise-spawn": "^6.0.1", + "@npmcli/run-script": "^6.0.0", + "cacache": "^17.0.0", + "fs-minipass": "^3.0.0", + "minipass": "^5.0.0", + "npm-package-arg": "^10.0.0", + "npm-packlist": "^7.0.0", + "npm-pick-manifest": "^8.0.0", + "npm-registry-fetch": "^14.0.0", + "proc-log": "^3.0.0", + "promise-retry": "^2.0.1", + "read-package-json": "^6.0.0", + "read-package-json-fast": "^3.0.0", + "sigstore": "^1.3.0", + "ssri": "^10.0.0", + "tar": "^6.1.11" + }, + "bin": { + "pacote": "lib/bin.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/pacote/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/pacote/node_modules/cacache": { + "version": "17.1.4", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.1.4.tgz", + "integrity": "sha512-/aJwG2l3ZMJ1xNAnqbMpA40of9dj/pIH3QfiuQSqjfPJF747VR0J/bHn+/KdNnHKc6XQcWt/AfRSBft82W1d2A==", + "dependencies": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^7.7.1", + "minipass": "^7.0.3", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/pacote/node_modules/cacache/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/pacote/node_modules/glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/pacote/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/pacote/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/pacote/node_modules/ssri": { + "version": "10.0.5", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.5.tgz", + "integrity": "sha512-bSf16tAFkGeRlUNDjXu8FzaMQt6g2HZJrun7mtMbIPOddxt3GLMSz5VWUWcqTJUPfLEaDIepGxv+bYQW49596A==", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/pacote/node_modules/ssri/node_modules/minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/pacote/node_modules/unique-filename": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", + "dependencies": { + "unique-slug": "^4.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/pacote/node_modules/unique-slug": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/parse-github-url": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/parse-github-url/-/parse-github-url-1.0.2.tgz", + "integrity": "sha512-kgBf6avCbO3Cn6+RnzRGLkUsv4ZVqv/VfAYkRsyBcgkshNvVBkRn1FEZcW0Jb+npXQWm2vHPnnOqFteZxRRGNw==", + "bin": { + "parse-github-url": "cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "node_modules/path-scurry": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.10.1.tgz", + "integrity": "sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==", + "dependencies": { + "lru-cache": "^9.1.1 || ^10.0.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.2.0.tgz", + "integrity": "sha512-2bIM8x+VAf6JT4bKAljS1qUWgMsqZRPGJS6FSahIMPVvctcNhyVp7AJu7quxOW9jwkryBReKZY5tY5JYv2n/7Q==", + "engines": { + "node": "14 || >=16.14" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==" + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/proc-log": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-3.0.0.tgz", + "integrity": "sha512-++Vn7NS4Xf9NacaU9Xq3URUuqZETPsf8L4j5/ckhaRYsfPeRyzGw+iDjFhV/Jr3uNmTvvddEJFWh5R1gRgUH8A==", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha1-mEcocL8igTL8vdhoEputEsPAKeM=" + }, + "node_modules/promise-retry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", + "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", + "dependencies": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/prompts-ncu": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/prompts-ncu/-/prompts-ncu-3.0.0.tgz", + "integrity": "sha512-qyz9UxZ5MlPKWVhWrCmSZ1ahm2GVYdjLb8og2sg0IPth1KRuhcggHGuijz0e41dkx35p1t1q3GRISGH7QGALFA==", + "dependencies": { + "kleur": "^4.0.1", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/proto-list": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", + "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==" + }, + "node_modules/psl": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz", + "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==" + }, + "node_modules/pupa": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/pupa/-/pupa-3.1.0.tgz", + "integrity": "sha512-FLpr4flz5xZTSJxSeaheeMKN/EDzMdK7b8PTOC6a5PYFKTucWbdqjgqaEyH0shFiSJrVB1+Qqi4Tk19ccU6Aug==", + "dependencies": { + "escape-goat": "^4.0.0" + }, + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/qs": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz", + "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/raw-loader": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/raw-loader/-/raw-loader-0.5.1.tgz", + "integrity": "sha1-DD0L6u2KAclm2Xh793goElKpeao=", + "dev": true + }, + "node_modules/rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dependencies": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "bin": { + "rc": "cli.js" + } + }, + "node_modules/rc-config-loader": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/rc-config-loader/-/rc-config-loader-4.1.3.tgz", + "integrity": "sha512-kD7FqML7l800i6pS6pvLyIE2ncbk9Du8Q0gp/4hMPhJU6ZxApkoLcGD8ZeqgiAlfwZ6BlETq6qqe+12DUL207w==", + "dependencies": { + "debug": "^4.3.4", + "js-yaml": "^4.1.0", + "json5": "^2.2.2", + "require-from-string": "^2.0.2" + } + }, + "node_modules/rc-config-loader/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/rc-config-loader/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/rc/node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + }, + "node_modules/rc/node_modules/strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/read-package-json": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/read-package-json/-/read-package-json-6.0.4.tgz", + "integrity": "sha512-AEtWXYfopBj2z5N5PbkAOeNHRPUg5q+Nen7QLxV8M2zJq1ym6/lCz3fYNTCXe19puu2d06jfHhrP7v/S2PtMMw==", + "dependencies": { + "glob": "^10.2.2", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^5.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/read-package-json-fast": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/read-package-json-fast/-/read-package-json-fast-3.0.2.tgz", + "integrity": "sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==", + "dependencies": { + "json-parse-even-better-errors": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/read-package-json/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/read-package-json/node_modules/glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/read-package-json/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rechoir": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz", + "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==", + "dev": true, + "dependencies": { + "resolve": "^1.20.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/registry-auth-token": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.0.2.tgz", + "integrity": "sha512-o/3ikDxtXaA59BmZuZrJZDJv8NMDGSj+6j6XaeBmHw8eY1i1qd9+6H+LjVvQXx3HN6aRCGa1cUdJ9RaJZUugnQ==", + "dependencies": { + "@pnpm/npm-conf": "^2.1.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/registry-url": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-6.0.1.tgz", + "integrity": "sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==", + "dependencies": { + "rc": "1.2.8" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/remote-git-tags": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/remote-git-tags/-/remote-git-tags-3.0.0.tgz", + "integrity": "sha512-C9hAO4eoEsX+OXA4rla66pXZQ+TLQ8T9dttgQj18yuKlPMTVkIkdYXvlMC55IuUsIkV6DpmQYi10JKFLaU+l7w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/request": { + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "deprecated": "request has been deprecated, see https://github.com/request/request/issues/3142", + "dependencies": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.5.0", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/request/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.8", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz", + "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==", + "dev": true, + "dependencies": { + "is-core-module": "^2.13.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==" + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/responselike": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz", + "integrity": "sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==", + "dependencies": { + "lowercase-keys": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==", + "engines": { + "node": ">= 4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "node_modules/schema-utils": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", + "dev": true, + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/script-loader": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/script-loader/-/script-loader-0.7.2.tgz", + "integrity": "sha512-UMNLEvgOAQuzK8ji8qIscM3GIrRCWN6MmMXGD4SD5l6cSycgGsCo0tX5xRnfQcoghqct0tjHjcykgI1PyBE2aA==", + "dev": true, + "dependencies": { + "raw-loader": "~0.5.1" + } + }, + "node_modules/semver": { + "version": "7.6.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.0.tgz", + "integrity": "sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-4.0.0.tgz", + "integrity": "sha512-0Ju4+6A8iOnpL/Thra7dZsSlOHYAHIeMxfhWQRI1/VLcT3WDBZKKtQt/QkBOsiIN9ZpuvHE6cGZ0x4glCMmfiA==", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/semver-utils": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/semver-utils/-/semver-utils-1.1.4.tgz", + "integrity": "sha512-EjnoLE5OGmDAVV/8YDoN5KiajNadjzIp9BAHOhYeQHt7j0UWxjmgsx4YD48wp4Ue1Qogq38F1GNUJNqF1kKKxA==" + }, + "node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "dev": true, + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==" + }, + "node_modules/shallow-clone": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz", + "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==", + "dev": true, + "dependencies": { + "kind-of": "^6.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "engines": { + "node": ">=8" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + }, + "node_modules/sigstore": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/sigstore/-/sigstore-1.9.0.tgz", + "integrity": "sha512-0Zjz0oe37d08VeOtBIuB6cRriqXse2e8w+7yIy2XSXjshRKxbc2KkhXjL229jXSxEm7UbcjS76wcJDGQddVI9A==", + "dependencies": { + "@sigstore/bundle": "^1.1.0", + "@sigstore/protobuf-specs": "^0.2.0", + "@sigstore/sign": "^1.0.0", + "@sigstore/tuf": "^1.0.3", + "make-fetch-happen": "^11.0.1" + }, + "bin": { + "sigstore": "bin/sigstore.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==" + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/smart-buffer": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", + "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "engines": { + "node": ">= 6.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.1.tgz", + "integrity": "sha512-B6w7tkwNid7ToxjZ08rQMT8M9BJAf8DKx8Ft4NivzH0zBUfd6jldGcisJn/RLgxcX3FPNDdNQCUEMMT79b+oCQ==", + "dependencies": { + "ip-address": "^9.0.5", + "smart-buffer": "^4.2.0" + }, + "engines": { + "node": ">= 10.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks-proxy-agent": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-7.0.0.tgz", + "integrity": "sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==", + "dependencies": { + "agent-base": "^6.0.2", + "debug": "^4.3.3", + "socks": "^2.6.2" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/socks-proxy-agent/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/socks-proxy-agent/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/source-map-support/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/spawn-please": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/spawn-please/-/spawn-please-2.0.2.tgz", + "integrity": "sha512-KM8coezO6ISQ89c1BzyWNtcn2V2kAVtwIXd3cN/V5a0xPYc1F/vydrRc01wsKFEQ/p+V1a4sw4z2yMITIXrgGw==", + "dependencies": { + "cross-spawn": "^7.0.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/spdx-correct": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", + "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", + "dependencies": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-exceptions": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", + "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==" + }, + "node_modules/spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-license-ids": { + "version": "3.0.17", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.17.tgz", + "integrity": "sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==" + }, + "node_modules/sprintf-js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", + "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==" + }, + "node_modules/sshpk": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.18.0.tgz", + "integrity": "sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==", + "dependencies": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + }, + "bin": { + "sshpk-conv": "bin/sshpk-conv", + "sshpk-sign": "bin/sshpk-sign", + "sshpk-verify": "bin/sshpk-verify" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.1.tgz", + "integrity": "sha512-0fk9zBqO67Nq5M/m45qHCJxylV/DhBlIOVExqgOMiCCrzrhU6tCibRXNqE3jwJLftzE9SNuZtYbpzcO+i9FiKw==", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tapable": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", + "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/tar": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", + "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", + "dependencies": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tar/node_modules/chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "engines": { + "node": ">=10" + } + }, + "node_modules/tar/node_modules/fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/tar/node_modules/fs-minipass/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tar/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tar/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/terser": { + "version": "5.29.2", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.29.2.tgz", + "integrity": "sha512-ZiGkhUBIM+7LwkNjXYJq8svgkd+QK3UUr0wJqY4MieaezBSAIPgbSPZyIx0idM6XWK5CMzSWa8MJIzmRcB8Caw==", + "dev": true, + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser-webpack-plugin": { + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz", + "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==", + "dev": true, + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.20", + "jest-worker": "^27.4.5", + "schema-utils": "^3.1.1", + "serialize-javascript": "^6.0.1", + "terser": "^5.26.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "uglify-js": { + "optional": true + } + } + }, + "node_modules/tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "dependencies": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/tough-cookie/node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/tuf-js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-1.1.7.tgz", + "integrity": "sha512-i3P9Kgw3ytjELUfpuKVDNBJvk4u5bXL6gskv572mcevPbSKCV3zt3djhmlEQ65yERjIbOSncy7U4cQJaB1CBCg==", + "dependencies": { + "@tufjs/models": "1.0.4", + "debug": "^4.3.4", + "make-fetch-happen": "^11.1.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/tuf-js/node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/tuf-js/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "dependencies": { + "safe-buffer": "^5.0.1" + }, + "engines": { + "node": "*" + } + }, + "node_modules/tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==" + }, + "node_modules/type-fest": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", + "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "dependencies": { + "is-typedarray": "^1.0.0" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true + }, + "node_modules/unique-string": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-3.0.0.tgz", + "integrity": "sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==", + "dependencies": { + "crypto-random-string": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/update-notifier": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-6.0.2.tgz", + "integrity": "sha512-EDxhTEVPZZRLWYcJ4ZXjGFN0oP7qYvbXWzEgRm/Yql4dHX5wDbvh89YHP6PK1lzZJYrMtXUuZZz8XGK+U6U1og==", + "dependencies": { + "boxen": "^7.0.0", + "chalk": "^5.0.1", + "configstore": "^6.0.0", + "has-yarn": "^3.0.0", + "import-lazy": "^4.0.0", + "is-ci": "^3.0.1", + "is-installed-globally": "^0.4.0", + "is-npm": "^6.0.0", + "is-yarn-global": "^0.4.0", + "latest-version": "^7.0.0", + "pupa": "^3.1.0", + "semver": "^7.3.7", + "semver-diff": "^4.0.0", + "xdg-basedir": "^5.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/yeoman/update-notifier?sponsor=1" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/uri-js/node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "node_modules/uuid": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", + "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==", + "deprecated": "Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details.", + "bin": { + "uuid": "bin/uuid" + } + }, + "node_modules/validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dependencies": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "node_modules/validate-npm-package-name": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.0.tgz", + "integrity": "sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==", + "dependencies": { + "builtins": "^5.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==", + "engines": [ + "node >=0.6.0" + ], + "dependencies": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "node_modules/watchpack": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.1.tgz", + "integrity": "sha512-8wrBCMtVhqcXP2Sup1ctSkga6uc2Bx0IIvKyT7yTFier5AXHooSI+QyQQAtTb7+E0IUCCKyTFmXqdqgum2XWGg==", + "dev": true, + "dependencies": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack": { + "version": "5.90.3", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.90.3.tgz", + "integrity": "sha512-h6uDYlWCctQRuXBs1oYpVe6sFcWedl0dpcVaTf/YF67J9bKvwJajFulMVSYKHrksMB3I/pIagRzDxwxkebuzKA==", + "dev": true, + "dependencies": { + "@types/eslint-scope": "^3.7.3", + "@types/estree": "^1.0.5", + "@webassemblyjs/ast": "^1.11.5", + "@webassemblyjs/wasm-edit": "^1.11.5", + "@webassemblyjs/wasm-parser": "^1.11.5", + "acorn": "^8.7.1", + "acorn-import-assertions": "^1.9.0", + "browserslist": "^4.21.10", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.15.0", + "es-module-lexer": "^1.2.1", + "eslint-scope": "5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.9", + "json-parse-even-better-errors": "^2.3.1", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^3.2.0", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.3.10", + "watchpack": "^2.4.0", + "webpack-sources": "^3.2.3" + }, + "bin": { + "webpack": "bin/webpack.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-cli": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-5.1.4.tgz", + "integrity": "sha512-pIDJHIEI9LR0yxHXQ+Qh95k2EvXpWzZ5l+d+jIo+RdSm9MiHfzazIxwwni/p7+x4eJZuvG1AJwgC4TNQ7NRgsg==", + "dev": true, + "dependencies": { + "@discoveryjs/json-ext": "^0.5.0", + "@webpack-cli/configtest": "^2.1.1", + "@webpack-cli/info": "^2.0.2", + "@webpack-cli/serve": "^2.0.5", + "colorette": "^2.0.14", + "commander": "^10.0.1", + "cross-spawn": "^7.0.3", + "envinfo": "^7.7.3", + "fastest-levenshtein": "^1.0.12", + "import-local": "^3.0.2", + "interpret": "^3.1.1", + "rechoir": "^0.8.0", + "webpack-merge": "^5.7.3" + }, + "bin": { + "webpack-cli": "bin/cli.js" + }, + "engines": { + "node": ">=14.15.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "5.x.x" + }, + "peerDependenciesMeta": { + "@webpack-cli/generators": { + "optional": true + }, + "webpack-bundle-analyzer": { + "optional": true + }, + "webpack-dev-server": { + "optional": true + } + } + }, + "node_modules/webpack-cli/node_modules/@webpack-cli/configtest": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-2.1.1.tgz", + "integrity": "sha512-wy0mglZpDSiSS0XHrVR+BAdId2+yxPSoJW8fsna3ZpYSlufjvxnP4YbKTCBZnNIcGN4r6ZPXV55X4mYExOfLmw==", + "dev": true, + "engines": { + "node": ">=14.15.0" + }, + "peerDependencies": { + "webpack": "5.x.x", + "webpack-cli": "5.x.x" + } + }, + "node_modules/webpack-cli/node_modules/@webpack-cli/info": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-2.0.2.tgz", + "integrity": "sha512-zLHQdI/Qs1UyT5UBdWNqsARasIA+AaF8t+4u2aS2nEpBQh2mWIVb8qAklq0eUENnC5mOItrIB4LiS9xMtph18A==", + "dev": true, + "engines": { + "node": ">=14.15.0" + }, + "peerDependencies": { + "webpack": "5.x.x", + "webpack-cli": "5.x.x" + } + }, + "node_modules/webpack-cli/node_modules/@webpack-cli/serve": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-2.0.5.tgz", + "integrity": "sha512-lqaoKnRYBdo1UgDX8uF24AfGMifWK19TxPmM5FHc2vAGxrJ/qtyUyFBWoY1tISZdelsQ5fBcOusifo5o5wSJxQ==", + "dev": true, + "engines": { + "node": ">=14.15.0" + }, + "peerDependencies": { + "webpack": "5.x.x", + "webpack-cli": "5.x.x" + }, + "peerDependenciesMeta": { + "webpack-dev-server": { + "optional": true + } + } + }, + "node_modules/webpack-cli/node_modules/commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/webpack-merge": { + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz", + "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==", + "dev": true, + "dependencies": { + "clone-deep": "^4.0.1", + "flat": "^5.0.2", + "wildcard": "^2.0.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/webpack-sources": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz", + "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==", + "dev": true, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack/node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wide-align": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", + "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "dependencies": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "node_modules/widest-line": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-4.0.1.tgz", + "integrity": "sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==", + "dependencies": { + "string-width": "^5.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/widest-line/node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/widest-line/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/wildcard": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz", + "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==", + "dev": true + }, + "node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi/node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/wrap-ansi/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/wrapper-webpack-plugin": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/wrapper-webpack-plugin/-/wrapper-webpack-plugin-2.2.2.tgz", + "integrity": "sha512-twLGZw0b2AEnz3LmsM/uCFRzGxE+XUlUPlJkCuHY3sI+uGO4dTJsgYee3ufWJaynAZYkpgQSKMSr49n9Yxalzg==", + "dev": true, + "peerDependencies": { + "webpack": ">=2" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "node_modules/write-file-atomic": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", + "dependencies": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "node_modules/xdg-basedir": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-5.1.0.tgz", + "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + }, + "dependencies": { + "@colors/colors": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz", + "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==", + "optional": true + }, + "@discoveryjs/json-ext": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz", + "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==", + "dev": true + }, + "@gar/promisify": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz", + "integrity": "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==" + }, + "@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "requires": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "dependencies": { + "emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + } + } + }, + "@jridgewell/gen-mapping": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", + "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", + "dev": true, + "requires": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true + }, + "@jridgewell/set-array": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", + "dev": true + }, + "@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", + "dev": true, + "requires": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "requires": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==" + }, + "@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "requires": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + } + }, + "@npmcli/fs": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.0.tgz", + "integrity": "sha512-7kZUAaLscfgbwBQRbvdMYaZOWyMEcPTH/tJjnyAWJ/dvvs9Ef+CERx/qJb9GExJpl1qipaDGn7KqHnFGGixd0w==", + "requires": { + "semver": "^7.3.5" + } + }, + "@npmcli/git": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-4.1.0.tgz", + "integrity": "sha512-9hwoB3gStVfa0N31ymBmrX+GuDGdVA/QWShZVqE0HK2Af+7QGGrCTbZia/SW0ImUTjTne7SP91qxDmtXvDHRPQ==", + "requires": { + "@npmcli/promise-spawn": "^6.0.0", + "lru-cache": "^7.4.4", + "npm-pick-manifest": "^8.0.0", + "proc-log": "^3.0.0", + "promise-inflight": "^1.0.1", + "promise-retry": "^2.0.1", + "semver": "^7.3.5", + "which": "^3.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + }, + "which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "requires": { + "isexe": "^2.0.0" + } + } + } + }, + "@npmcli/installed-package-contents": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/installed-package-contents/-/installed-package-contents-2.0.2.tgz", + "integrity": "sha512-xACzLPhnfD51GKvTOOuNX2/V4G4mz9/1I2MfDoye9kBM3RYe5g2YbscsaGoTlaWqkxeiapBWyseULVKpSVHtKQ==", + "requires": { + "npm-bundled": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + } + }, + "@npmcli/move-file": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-2.0.1.tgz", + "integrity": "sha512-mJd2Z5TjYWq/ttPLLGqArdtnC74J6bOzg4rMDnN+p1xTacZ2yPRCk2y0oSWQtygLR9YVQXgOcONrwtnk3JupxQ==", + "requires": { + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2" + }, + "dependencies": { + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==" + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "requires": { + "glob": "^7.1.3" + } + } + } + }, + "@npmcli/node-gyp": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-3.0.0.tgz", + "integrity": "sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==" + }, + "@npmcli/promise-spawn": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-6.0.2.tgz", + "integrity": "sha512-gGq0NJkIGSwdbUt4yhdF8ZrmkGKVz9vAdVzpOfnom+V8PLSmSOVhZwbNvZZS1EYcJN5hzzKBxmmVVAInM6HQLg==", + "requires": { + "which": "^3.0.0" + }, + "dependencies": { + "which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "requires": { + "isexe": "^2.0.0" + } + } + } + }, + "@npmcli/run-script": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-6.0.2.tgz", + "integrity": "sha512-NCcr1uQo1k5U+SYlnIrbAh3cxy+OQT1VtqiAbxdymSlptbzBb62AjH2xXgjNCoP073hoa1CfCAcwoZ8k96C4nA==", + "requires": { + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/promise-spawn": "^6.0.0", + "node-gyp": "^9.0.0", + "read-package-json-fast": "^3.0.0", + "which": "^3.0.0" + }, + "dependencies": { + "which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz", + "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==", + "requires": { + "isexe": "^2.0.0" + } + } + } + }, + "@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "optional": true + }, + "@pnpm/config.env-replace": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz", + "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==" + }, + "@pnpm/network.ca-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz", + "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==", + "requires": { + "graceful-fs": "4.2.10" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" + } + } + }, + "@pnpm/npm-conf": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.2.2.tgz", + "integrity": "sha512-UA91GwWPhFExt3IizW6bOeY/pQ0BkuNwKjk9iQW9KqxluGCrg4VenZ0/L+2Y0+ZOtme72EVvg6v0zo3AMQRCeA==", + "requires": { + "@pnpm/config.env-replace": "^1.1.0", + "@pnpm/network.ca-file": "^1.0.1", + "config-chain": "^1.1.11" + } + }, + "@sigstore/bundle": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-1.1.0.tgz", + "integrity": "sha512-PFutXEy0SmQxYI4texPw3dd2KewuNqv7OuK1ZFtY2fM754yhvG2KdgwIhRnoEE2uHdtdGNQ8s0lb94dW9sELog==", + "requires": { + "@sigstore/protobuf-specs": "^0.2.0" + } + }, + "@sigstore/protobuf-specs": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.2.1.tgz", + "integrity": "sha512-XTWVxnWJu+c1oCshMLwnKvz8ZQJJDVOlciMfgpJBQbThVjKTCG8dwyhgLngBD2KN0ap9F/gOV8rFDEx8uh7R2A==" + }, + "@sigstore/sign": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-1.0.0.tgz", + "integrity": "sha512-INxFVNQteLtcfGmcoldzV6Je0sbbfh9I16DM4yJPw3j5+TFP8X6uIiA18mvpEa9yyeycAKgPmOA3X9hVdVTPUA==", + "requires": { + "@sigstore/bundle": "^1.1.0", + "@sigstore/protobuf-specs": "^0.2.0", + "make-fetch-happen": "^11.0.1" + } + }, + "@sigstore/tuf": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@sigstore/tuf/-/tuf-1.0.3.tgz", + "integrity": "sha512-2bRovzs0nJZFlCN3rXirE4gwxCn97JNjMmwpecqlbgV9WcxX7WRuIrgzx/X7Ib7MYRbyUTpBYE0s2x6AmZXnlg==", + "requires": { + "@sigstore/protobuf-specs": "^0.2.0", + "tuf-js": "^1.1.7" + } + }, + "@sindresorhus/is": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz", + "integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==" + }, + "@szmarczak/http-timer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz", + "integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==", + "requires": { + "defer-to-connect": "^2.0.1" + } + }, + "@tootallnate/once": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz", + "integrity": "sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==" + }, + "@tufjs/canonical-json": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@tufjs/canonical-json/-/canonical-json-1.0.0.tgz", + "integrity": "sha512-QTnf++uxunWvG2z3UFNzAoQPHxnSXOwtaI3iJ+AohhV+5vONuArPjJE7aPXPVXfXJsqrVbZBu9b81AJoSd09IQ==" + }, + "@tufjs/models": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@tufjs/models/-/models-1.0.4.tgz", + "integrity": "sha512-qaGV9ltJP0EO25YfFUPhxRVK0evXFIAGicsVXuRim4Ed9cjPxYhNnNJ49SFmbeLgtxpslIkX317IgpfcHPVj/A==", + "requires": { + "@tufjs/canonical-json": "1.0.0", + "minimatch": "^9.0.0" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + } + } + }, + "@types/eslint": { + "version": "8.56.5", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.56.5.tgz", + "integrity": "sha512-u5/YPJHo1tvkSF2CE0USEkxon82Z5DBy2xR+qfyYNszpX9qcs4sT6uq2kBbj4BXY1+DBGDPnrhMZV3pKWGNukw==", + "dev": true, + "requires": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "@types/eslint-scope": { + "version": "3.7.7", + "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz", + "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==", + "dev": true, + "requires": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "@types/estree": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz", + "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==", + "dev": true + }, + "@types/http-cache-semantics": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", + "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==" + }, + "@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true + }, + "@types/node": { + "version": "20.11.28", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.28.tgz", + "integrity": "sha512-M/GPWVS2wLkSkNHVeLkrF2fD5Lx5UC4PxA0uZcKc6QqbIQUJyW1jVjueJYi1z8n0I5PxYrtpnPnWglE+y9A0KA==", + "dev": true, + "requires": { + "undici-types": "~5.26.4" + } + }, + "@webassemblyjs/ast": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz", + "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==", + "dev": true, + "requires": { + "@webassemblyjs/helper-numbers": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6" + } + }, + "@webassemblyjs/floating-point-hex-parser": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz", + "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==", + "dev": true + }, + "@webassemblyjs/helper-api-error": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz", + "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==", + "dev": true + }, + "@webassemblyjs/helper-buffer": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz", + "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==", + "dev": true + }, + "@webassemblyjs/helper-numbers": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz", + "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==", + "dev": true, + "requires": { + "@webassemblyjs/floating-point-hex-parser": "1.11.6", + "@webassemblyjs/helper-api-error": "1.11.6", + "@xtuc/long": "4.2.2" + } + }, + "@webassemblyjs/helper-wasm-bytecode": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz", + "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==", + "dev": true + }, + "@webassemblyjs/helper-wasm-section": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz", + "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/wasm-gen": "1.12.1" + } + }, + "@webassemblyjs/ieee754": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz", + "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==", + "dev": true, + "requires": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "@webassemblyjs/leb128": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz", + "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==", + "dev": true, + "requires": { + "@xtuc/long": "4.2.2" + } + }, + "@webassemblyjs/utf8": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz", + "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==", + "dev": true + }, + "@webassemblyjs/wasm-edit": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz", + "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/helper-wasm-section": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-opt": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1", + "@webassemblyjs/wast-printer": "1.12.1" + } + }, + "@webassemblyjs/wasm-gen": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz", + "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "@webassemblyjs/wasm-opt": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz", + "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1" + } + }, + "@webassemblyjs/wasm-parser": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz", + "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-api-error": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "@webassemblyjs/wast-printer": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz", + "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.12.1", + "@xtuc/long": "4.2.2" + } + }, + "@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", + "dev": true + }, + "@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", + "dev": true + }, + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "acorn": { + "version": "8.11.3", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz", + "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==", + "dev": true + }, + "acorn-import-assertions": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz", + "integrity": "sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==", + "dev": true, + "requires": {} + }, + "agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "requires": { + "debug": "4" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "agentkeepalive": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.5.0.tgz", + "integrity": "sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==", + "requires": { + "humanize-ms": "^1.2.1" + } + }, + "aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "requires": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + } + }, + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true, + "requires": {} + }, + "ansi-align": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz", + "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==", + "requires": { + "string-width": "^4.1.0" + } + }, + "ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==" + }, + "ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==" + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==" + }, + "are-we-there-yet": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz", + "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==", + "requires": { + "delegates": "^1.0.0", + "readable-stream": "^3.6.0" + }, + "dependencies": { + "readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + } + } + }, + "argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==" + }, + "asn1": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz", + "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==", + "requires": { + "safer-buffer": "~2.1.0" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==" + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==" + }, + "aws4": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz", + "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==" + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==", + "requires": { + "tweetnacl": "^0.14.3" + } + }, + "boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==" + }, + "boxen": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz", + "integrity": "sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==", + "requires": { + "ansi-align": "^3.0.1", + "camelcase": "^7.0.1", + "chalk": "^5.2.0", + "cli-boxes": "^3.0.0", + "string-width": "^5.1.2", + "type-fest": "^2.13.0", + "widest-line": "^4.0.1", + "wrap-ansi": "^8.1.0" + }, + "dependencies": { + "emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "browserslist": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz", + "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==", + "dev": true, + "requires": { + "caniuse-lite": "^1.0.30001587", + "electron-to-chromium": "^1.4.668", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" + } + }, + "buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==" + }, + "builtins": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/builtins/-/builtins-5.0.1.tgz", + "integrity": "sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==", + "requires": { + "semver": "^7.0.0" + } + }, + "cacheable-lookup": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz", + "integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==" + }, + "cacheable-request": { + "version": "10.2.14", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz", + "integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==", + "requires": { + "@types/http-cache-semantics": "^4.0.2", + "get-stream": "^6.0.1", + "http-cache-semantics": "^4.1.1", + "keyv": "^4.5.3", + "mimic-response": "^4.0.0", + "normalize-url": "^8.0.0", + "responselike": "^3.0.0" + } + }, + "camelcase": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz", + "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==" + }, + "caniuse-lite": { + "version": "1.0.30001598", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001598.tgz", + "integrity": "sha512-j8mQRDziG94uoBfeFuqsJUNECW37DXpnvhcMJMdlH2u3MRkq1sAI0LJcXP1i/Py0KbSIC4UDj8YHPrTn5YsL+Q==", + "dev": true + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "chalk": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==" + }, + "cheerio": { + "version": "0.22.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.22.0.tgz", + "integrity": "sha512-8/MzidM6G/TgRelkzDG13y3Y9LxBjCb+8yOEZ9+wwq5gVF2w2pV0wmHvjfT0RvuxGyR7UEuK36r+yYMbT4uKgA==", + "requires": { + "css-select": "~1.2.0", + "dom-serializer": "~0.1.0", + "entities": "~1.1.1", + "htmlparser2": "^3.9.1", + "lodash.assignin": "^4.0.9", + "lodash.bind": "^4.1.4", + "lodash.defaults": "^4.0.1", + "lodash.filter": "^4.4.0", + "lodash.flatten": "^4.2.0", + "lodash.foreach": "^4.3.0", + "lodash.map": "^4.4.0", + "lodash.merge": "^4.4.0", + "lodash.pick": "^4.2.1", + "lodash.reduce": "^4.4.0", + "lodash.reject": "^4.4.0", + "lodash.some": "^4.4.0" + } + }, + "chrome-trace-event": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz", + "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==", + "dev": true + }, + "ci-info": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==" + }, + "clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==" + }, + "cli-boxes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz", + "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==" + }, + "cli-table3": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz", + "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==", + "requires": { + "@colors/colors": "1.5.0", + "string-width": "^4.2.0" + } + }, + "clone-deep": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz", + "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4", + "kind-of": "^6.0.2", + "shallow-clone": "^3.0.0" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "color-support": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==" + }, + "colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true + }, + "combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "requires": { + "delayed-stream": "~1.0.0" + } + }, + "commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "config-chain": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz", + "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==", + "requires": { + "ini": "^1.3.4", + "proto-list": "~1.2.1" + }, + "dependencies": { + "ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + } + } + }, + "configstore": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-6.0.0.tgz", + "integrity": "sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==", + "requires": { + "dot-prop": "^6.0.1", + "graceful-fs": "^4.2.6", + "unique-string": "^3.0.0", + "write-file-atomic": "^3.0.3", + "xdg-basedir": "^5.0.1" + } + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "crypto-random-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-4.0.0.tgz", + "integrity": "sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==", + "requires": { + "type-fest": "^1.0.1" + }, + "dependencies": { + "type-fest": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz", + "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==" + } + } + }, + "css-select": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-1.2.0.tgz", + "integrity": "sha512-dUQOBoqdR7QwV90WysXPLXG5LO7nhYBgiWVfxF80DKPF8zx1t/pUd2FYy73emg3zrjtM6dzmYgbHKfV2rxiHQA==", + "requires": { + "boolbase": "~1.0.0", + "css-what": "2.1", + "domutils": "1.5.1", + "nth-check": "~1.0.1" + } + }, + "css-what": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-2.1.3.tgz", + "integrity": "sha512-a+EPoD+uZiNfh+5fxw2nO9QwFa6nJe2Or35fGY6Ipw1R3R4AGz1d1TEZrCegvw2YTmZ0jXirGYlzxxpYSHwpEg==" + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "requires": { + "mimic-response": "^3.1.0" + }, + "dependencies": { + "mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==" + } + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==" + }, + "defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==" + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==" + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==" + }, + "dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "requires": { + "path-type": "^4.0.0" + } + }, + "dom-serializer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.1.tgz", + "integrity": "sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==", + "requires": { + "domelementtype": "^1.3.0", + "entities": "^1.1.1" + } + }, + "domelementtype": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.1.tgz", + "integrity": "sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==" + }, + "domhandler": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.4.2.tgz", + "integrity": "sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==", + "requires": { + "domelementtype": "1" + } + }, + "domutils": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz", + "integrity": "sha512-gSu5Oi/I+3wDENBsOWBiRK1eoGxcywYSqg3rR960/+EfY0CF4EX1VPkgHOZ3WiS/Jg2DtliF6BhWcHlfpYUcGw==", + "requires": { + "dom-serializer": "0", + "domelementtype": "1" + } + }, + "dot-prop": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz", + "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==", + "requires": { + "is-obj": "^2.0.0" + } + }, + "eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" + }, + "ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==", + "requires": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "electron-to-chromium": { + "version": "1.4.708", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.708.tgz", + "integrity": "sha512-iWgEEvREL4GTXXHKohhh33+6Y8XkPI5eHihDmm8zUk5Zo7HICEW+wI/j5kJ2tbuNUCXJ/sNXa03ajW635DiJXA==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "encoding": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", + "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", + "optional": true, + "requires": { + "iconv-lite": "^0.6.2" + } + }, + "enhanced-resolve": { + "version": "5.16.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.16.0.tgz", + "integrity": "sha512-O+QWCviPNSSLAD9Ucn8Awv+poAkqn3T1XY5/N7kR7rQO9yfSGWkYZDwpJ+iKF7B8rxaQKWngSqACpgzeapSyoA==", + "dev": true, + "requires": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + } + }, + "entities": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz", + "integrity": "sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==" + }, + "env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==" + }, + "envinfo": { + "version": "7.11.1", + "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.11.1.tgz", + "integrity": "sha512-8PiZgZNIB4q/Lw4AhOvAfB/ityHAd2bli3lESSWmWSzSsl5dKpy5N1d1Rfkd2teq/g9xN90lc6o98DOjMeYHpg==", + "dev": true + }, + "err-code": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", + "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==" + }, + "es-module-lexer": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.4.1.tgz", + "integrity": "sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==", + "dev": true + }, + "escalade": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz", + "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==", + "dev": true + }, + "escape-goat": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-goat/-/escape-goat-4.0.0.tgz", + "integrity": "sha512-2Sd4ShcWxbx6OY1IHyla/CVNwvg7XwZVoXZHcSu9w9SReNP1EzzD5T8NWKIR38fIqEns9kDWKUQTXXAmlDrdPg==" + }, + "eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "requires": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + } + }, + "esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "requires": { + "estraverse": "^5.2.0" + }, + "dependencies": { + "estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true + } + } + }, + "estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true + }, + "events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "dev": true + }, + "exponential-backoff": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.1.tgz", + "integrity": "sha512-dX7e/LHVJ6W3DE1MHWi9S1EYzDESENfLrYohG2G++ovZrYOkm4Knwa0mc1cn84xJOR4KEU0WSchhLbd0UklbHw==" + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==" + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" + }, + "fast-glob": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", + "requires": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "dependencies": { + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "requires": { + "fill-range": "^7.0.1" + } + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "requires": { + "is-glob": "^4.0.1" + } + }, + "is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==" + }, + "micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "requires": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + } + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "requires": { + "is-number": "^7.0.0" + } + } + } + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fast-memoize": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/fast-memoize/-/fast-memoize-2.5.2.tgz", + "integrity": "sha512-Ue0LwpDYErFbmNnZSF0UH6eImUwDmogUO1jyE+JbN2gsQz/jICm1Ve7t9QT0rNSsfJt+Hs4/S3GnsDVjL4HVrw==" + }, + "fastest-levenshtein": { + "version": "1.0.16", + "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz", + "integrity": "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==", + "dev": true + }, + "fastq": { + "version": "1.17.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz", + "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==", + "requires": { + "reusify": "^1.0.4" + } + }, + "flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true + }, + "foreground-child": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz", + "integrity": "sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==", + "requires": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "dependencies": { + "signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==" + } + } + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.6", + "mime-types": "^2.1.12" + } + }, + "form-data-encoder": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz", + "integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==" + }, + "fp-and-or": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/fp-and-or/-/fp-and-or-0.1.4.tgz", + "integrity": "sha512-+yRYRhpnFPWXSly/6V4Lw9IfOV26uu30kynGJ03PW+MnjOEQe45RZ141QcS0aJehYBYA50GfCDnsRbFJdhssRw==" + }, + "fs-minipass": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz", + "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==", + "requires": { + "minipass": "^7.0.3" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==" + }, + "gauge": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz", + "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==", + "requires": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.3", + "console-control-strings": "^1.1.0", + "has-unicode": "^2.0.1", + "signal-exit": "^3.0.7", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.5" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + } + } + } + }, + "get-stdin": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-8.0.0.tgz", + "integrity": "sha512-sY22aA6xchAzprjyqmSEQv4UbAAzRN0L2dQB0NlN5acTTK9Don6nhoc3eAbUnpZiCANAMfd/+40kVdKfFygohg==" + }, + "get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==" + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", + "dev": true + }, + "global-dirs": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz", + "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==", + "requires": { + "ini": "2.0.0" + }, + "dependencies": { + "ini": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz", + "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==" + } + } + }, + "globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "requires": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + } + }, + "got": { + "version": "12.6.1", + "resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz", + "integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==", + "requires": { + "@sindresorhus/is": "^5.2.0", + "@szmarczak/http-timer": "^5.0.1", + "cacheable-lookup": "^7.0.0", + "cacheable-request": "^10.2.8", + "decompress-response": "^6.0.0", + "form-data-encoder": "^2.1.2", + "get-stream": "^6.0.1", + "http2-wrapper": "^2.1.10", + "lowercase-keys": "^3.0.0", + "p-cancelable": "^3.0.0", + "responselike": "^3.0.0" + } + }, + "graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==" + }, + "har-validator": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", + "requires": { + "ajv": "^6.12.3", + "har-schema": "^2.0.0" + } + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==" + }, + "has-yarn": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz", + "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==" + }, + "hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "requires": { + "function-bind": "^1.1.2" + } + }, + "hosted-git-info": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-5.2.1.tgz", + "integrity": "sha512-xIcQYMnhcx2Nr4JTjsFmwwnr9vldugPy9uVm0o87bjqqWMv9GaqsTeT+i99wTl0mk1uLxJtHxLb8kymqTENQsw==", + "requires": { + "lru-cache": "^7.5.1" + }, + "dependencies": { + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + } + } + }, + "htmlparser2": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.10.1.tgz", + "integrity": "sha512-IgieNijUMbkDovyoKObU1DUhm1iwNYE/fuifEoEHfd1oZKZDaONBSkal7Y01shxsM49R4XaMdGez3WnF9UfiCQ==", + "requires": { + "domelementtype": "^1.3.1", + "domhandler": "^2.3.0", + "domutils": "^1.5.1", + "entities": "^1.1.1", + "inherits": "^2.0.1", + "readable-stream": "^3.1.1" + }, + "dependencies": { + "readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + }, + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==" + }, + "string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "requires": { + "safe-buffer": "~5.2.0" + } + } + } + }, + "http-cache-semantics": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz", + "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==" + }, + "http-proxy-agent": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz", + "integrity": "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==", + "requires": { + "@tootallnate/once": "2", + "agent-base": "6", + "debug": "4" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==", + "requires": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + } + }, + "http2-wrapper": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz", + "integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==", + "requires": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.2.0" + } + }, + "https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "requires": { + "agent-base": "6", + "debug": "4" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "requires": { + "ms": "^2.0.0" + } + }, + "iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "optional": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + } + }, + "ignore": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz", + "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==" + }, + "ignore-walk": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-6.0.4.tgz", + "integrity": "sha512-t7sv42WkwFkyKbivUCglsQW5YWMskWtbEf4MNKX5u/CCWHKSPzN4FtBQGsQZgCLbxOzpVlcbWVK5KB3auIOjSw==", + "requires": { + "minimatch": "^9.0.0" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + } + } + }, + "import-lazy": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz", + "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==" + }, + "import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "requires": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "dependencies": { + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "requires": { + "find-up": "^4.0.0" + } + } + } + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=" + }, + "indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==" + }, + "infer-owner": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz", + "integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==" + }, + "interpret": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-3.1.1.tgz", + "integrity": "sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==", + "dev": true + }, + "ip-address": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz", + "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==", + "requires": { + "jsbn": "1.1.0", + "sprintf-js": "^1.1.3" + }, + "dependencies": { + "jsbn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz", + "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==" + } + } + }, + "is-ci": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz", + "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==", + "requires": { + "ci-info": "^3.2.0" + } + }, + "is-core-module": { + "version": "2.13.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.1.tgz", + "integrity": "sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==", + "requires": { + "hasown": "^2.0.0" + } + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==" + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==" + }, + "is-installed-globally": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz", + "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==", + "requires": { + "global-dirs": "^3.0.0", + "is-path-inside": "^3.0.2" + } + }, + "is-lambda": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", + "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==" + }, + "is-npm": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-6.0.0.tgz", + "integrity": "sha512-JEjxbSmtPSt1c8XTkVrlujcXdKV1/tvuQ7GwKcAlyiVLeYFQ2VHat8xfrDJsIkhCdF/tZ7CiIR3sy141c6+gPQ==" + }, + "is-obj": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz", + "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==" + }, + "is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==" + }, + "is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "dev": true, + "requires": { + "isobject": "^3.0.1" + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-yarn-global": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.4.1.tgz", + "integrity": "sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "jackspeak": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.6.tgz", + "integrity": "sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==", + "requires": { + "@isaacs/cliui": "^8.0.2", + "@pkgjs/parseargs": "^0.11.0" + } + }, + "jest-worker": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", + "dev": true, + "requires": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + } + }, + "jju": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/jju/-/jju-1.4.0.tgz", + "integrity": "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==" + }, + "js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "requires": { + "argparse": "^2.0.1" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==" + }, + "json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==" + }, + "json-parse-even-better-errors": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.1.tgz", + "integrity": "sha512-aatBvbL26wVUCLmbWdCpeu9iF5wOyWpagiKkInA+kfws3sWdBrTnsvN2CKcyCYyUrc7rebNBlK6+kteg7ksecg==" + }, + "json-parse-helpfulerror": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/json-parse-helpfulerror/-/json-parse-helpfulerror-1.0.3.tgz", + "integrity": "sha512-XgP0FGR77+QhUxjXkwOMkC94k3WtqEBfcnjWqhRd82qTat4SWKRE+9kUnynz/shm3I4ea2+qISvTIeGTNU7kJg==", + "requires": { + "jju": "^1.1.0" + } + }, + "json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==" + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==" + }, + "jsonlines": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsonlines/-/jsonlines-0.1.1.tgz", + "integrity": "sha512-ekDrAGso79Cvf+dtm+mL8OBI2bmAOt3gssYs833De/C9NmIpWDWyUO4zPgB5x2/OhY366dkhgfPMYfwZF7yOZA==" + }, + "jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==" + }, + "jsprim": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz", + "integrity": "sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.4.0", + "verror": "1.10.0" + } + }, + "keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "requires": { + "json-buffer": "3.0.1" + } + }, + "kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "dev": true + }, + "kleur": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", + "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==" + }, + "latest-version": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-7.0.0.tgz", + "integrity": "sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==", + "requires": { + "package-json": "^8.1.0" + } + }, + "loader-runner": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz", + "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==", + "dev": true + }, + "lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" + }, + "lodash.assignin": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assignin/-/lodash.assignin-4.2.0.tgz", + "integrity": "sha512-yX/rx6d/UTVh7sSVWVSIMjfnz95evAgDFdb1ZozC35I9mSFCkmzptOzevxjgbQUsc78NR44LVHWjsoMQXy9FDg==" + }, + "lodash.bind": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/lodash.bind/-/lodash.bind-4.2.1.tgz", + "integrity": "sha512-lxdsn7xxlCymgLYo1gGvVrfHmkjDiyqVv62FAeF2i5ta72BipE1SLxw8hPEPLhD4/247Ijw07UQH7Hq/chT5LA==" + }, + "lodash.defaults": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", + "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==" + }, + "lodash.filter": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.filter/-/lodash.filter-4.6.0.tgz", + "integrity": "sha512-pXYUy7PR8BCLwX5mgJ/aNtyOvuJTdZAo9EQFUvMIYugqmJxnrYaANvTbgndOzHSCSR0wnlBBfRXJL5SbWxo3FQ==" + }, + "lodash.flatten": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz", + "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==" + }, + "lodash.foreach": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.foreach/-/lodash.foreach-4.5.0.tgz", + "integrity": "sha512-aEXTF4d+m05rVOAUG3z4vZZ4xVexLKZGF0lIxuHZ1Hplpk/3B6Z1+/ICICYRLm7c41Z2xiejbkCkJoTlypoXhQ==" + }, + "lodash.map": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.map/-/lodash.map-4.6.0.tgz", + "integrity": "sha512-worNHGKLDetmcEYDvh2stPCrrQRkP20E4l0iIS7F8EvzMqBBi7ltvFN5m1HvTf1P7Jk1txKhvFcmYsCr8O2F1Q==" + }, + "lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==" + }, + "lodash.pick": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz", + "integrity": "sha512-hXt6Ul/5yWjfklSGvLQl8vM//l3FtyHZeuelpzK6mm99pNvN9yTDruNZPEJZD1oWrqo+izBmB7oUfWgcCX7s4Q==" + }, + "lodash.reduce": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reduce/-/lodash.reduce-4.6.0.tgz", + "integrity": "sha512-6raRe2vxCYBhpBu+B+TtNGUzah+hQjVdu3E17wfusjyrXBka2nBS8OH/gjVZ5PvHOhWmIZTYri09Z6n/QfnNMw==" + }, + "lodash.reject": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reject/-/lodash.reject-4.6.0.tgz", + "integrity": "sha512-qkTuvgEzYdyhiJBx42YPzPo71R1aEr0z79kAv7Ixg8wPFEjgRgJdUsGMG3Hf3OYSF/kHI79XhNlt+5Ar6OzwxQ==" + }, + "lodash.some": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz", + "integrity": "sha512-j7MJE+TuT51q9ggt4fSgVqro163BEFjAt3u97IqU+JA2DkWl80nFTrowzLpZ/BnpN7rrl0JA/593NAdd8p/scQ==" + }, + "lowercase-keys": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz", + "integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==" + }, + "make-fetch-happen": { + "version": "11.1.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-11.1.1.tgz", + "integrity": "sha512-rLWS7GCSTcEujjVBs2YqG7Y4643u8ucvCJeSRqiLYhesrDuzeuFIk37xREzAsfQaqzl8b9rNCE4m6J8tvX4Q8w==", + "requires": { + "agentkeepalive": "^4.2.1", + "cacache": "^17.0.0", + "http-cache-semantics": "^4.1.1", + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "is-lambda": "^1.0.1", + "lru-cache": "^7.7.1", + "minipass": "^5.0.0", + "minipass-fetch": "^3.0.0", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "socks-proxy-agent": "^7.0.0", + "ssri": "^10.0.0" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "cacache": { + "version": "17.1.4", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.1.4.tgz", + "integrity": "sha512-/aJwG2l3ZMJ1xNAnqbMpA40of9dj/pIH3QfiuQSqjfPJF747VR0J/bHn+/KdNnHKc6XQcWt/AfRSBft82W1d2A==", + "requires": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^7.7.1", + "minipass": "^7.0.3", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "ssri": { + "version": "10.0.5", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.5.tgz", + "integrity": "sha512-bSf16tAFkGeRlUNDjXu8FzaMQt6g2HZJrun7mtMbIPOddxt3GLMSz5VWUWcqTJUPfLEaDIepGxv+bYQW49596A==", + "requires": { + "minipass": "^7.0.3" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "unique-filename": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", + "requires": { + "unique-slug": "^4.0.0" + } + }, + "unique-slug": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", + "requires": { + "imurmurhash": "^0.1.4" + } + } + } + }, + "merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==" + }, + "mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==" + }, + "mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "requires": { + "mime-db": "1.52.0" + } + }, + "mimic-response": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz", + "integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==" + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==" + }, + "minipass": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", + "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==" + }, + "minipass-collect": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", + "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-fetch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.4.tgz", + "integrity": "sha512-jHAqnA728uUpIaFm7NWsCnqKT6UqZz7GcI/bDpPATuwYyKwJwW0remxSCxUlKiEty+eopHGa3oc8WxgQ1FFJqg==", + "requires": { + "encoding": "^0.1.13", + "minipass": "^7.0.3", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-json-stream": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minipass-json-stream/-/minipass-json-stream-1.0.1.tgz", + "integrity": "sha512-ODqY18UZt/I8k+b7rl2AENgbWE8IDYam+undIJONvigAz8KR5GWblsFTEfQs0WODsjbSXWlm+JHEv8Gr6Tfdbg==", + "requires": { + "jsonparse": "^1.3.1", + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-sized": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz", + "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "requires": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "ncu": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/ncu/-/ncu-0.2.1.tgz", + "integrity": "sha512-uEOi3lTWbpR2ScjGbg3gRfmIMQjdGh/15bXUBC7MBcUkf4TbB+ozIDWBfpGnEhDUs7lFTYMDERBHFssD2HJM4A==", + "requires": { + "cheerio": "^0.22.0", + "request": "^2.79.0" + } + }, + "negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==" + }, + "neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true + }, + "node-gyp": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-9.4.1.tgz", + "integrity": "sha512-OQkWKbjQKbGkMf/xqI1jjy3oCTgMKJac58G2+bjZb3fza6gW2YrCSdMQYaoTb70crvE//Gngr4f0AgVHmqHvBQ==", + "requires": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^7.1.4", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^10.0.3", + "nopt": "^6.0.0", + "npmlog": "^6.0.0", + "rimraf": "^3.0.2", + "semver": "^7.3.5", + "tar": "^6.1.2", + "which": "^2.0.2" + }, + "dependencies": { + "@npmcli/fs": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-2.1.2.tgz", + "integrity": "sha512-yOJKRvohFOaLqipNtwYB9WugyZKhC/DZC4VYPmpaCzDBrA8YpK3qHZ8/HGscMnE4GqbkLNuVcCnxkeQEdGt6LQ==", + "requires": { + "@gar/promisify": "^1.1.3", + "semver": "^7.3.5" + } + }, + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "cacache": { + "version": "16.1.3", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.1.3.tgz", + "integrity": "sha512-/+Emcj9DAXxX4cwlLmRI9c166RuL3w30zp4R7Joiv2cQTtTtA+jeuCAjH3ZlGnYS3tKENSrKhAzVVP9GVyzeYQ==", + "requires": { + "@npmcli/fs": "^2.1.0", + "@npmcli/move-file": "^2.0.0", + "chownr": "^2.0.0", + "fs-minipass": "^2.1.0", + "glob": "^8.0.1", + "infer-owner": "^1.0.4", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "mkdirp": "^1.0.4", + "p-map": "^4.0.0", + "promise-inflight": "^1.0.1", + "rimraf": "^3.0.2", + "ssri": "^9.0.0", + "tar": "^6.1.11", + "unique-filename": "^2.0.0" + }, + "dependencies": { + "glob": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz", + "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^5.0.1", + "once": "^1.3.0" + } + } + } + }, + "chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==" + }, + "fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "requires": { + "minipass": "^3.0.0" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + }, + "make-fetch-happen": { + "version": "10.2.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz", + "integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==", + "requires": { + "agentkeepalive": "^4.2.1", + "cacache": "^16.1.0", + "http-cache-semantics": "^4.1.0", + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "is-lambda": "^1.0.1", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-fetch": "^2.0.3", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "socks-proxy-agent": "^7.0.0", + "ssri": "^9.0.0" + } + }, + "minimatch": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz", + "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==", + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "minipass-fetch": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-2.1.2.tgz", + "integrity": "sha512-LT49Zi2/WMROHYoqGgdlQIZh8mLPZmOrN2NdJjMXxYe4nkN6FUyuPuOAOedNJDrx0IRGg9+4guZewtp8hE6TxA==", + "requires": { + "encoding": "^0.1.13", + "minipass": "^3.1.6", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + } + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==" + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "requires": { + "glob": "^7.1.3" + } + }, + "ssri": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-9.0.1.tgz", + "integrity": "sha512-o57Wcn66jMQvfHG1FlYbWeZWW/dHZhJXjpIcTfXldXEk5nz5lStPo3mK0OJQfGR3RbZUlbISexbljkJzuEj/8Q==", + "requires": { + "minipass": "^3.1.1" + } + }, + "unique-filename": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-2.0.1.tgz", + "integrity": "sha512-ODWHtkkdx3IAR+veKxFV+VBkUMcN+FaqzUUd7IZzt+0zhDZFPFxhlqwPF3YQvMHx1TD0tdgYl+kuPnJ8E6ql7A==", + "requires": { + "unique-slug": "^3.0.0" + } + }, + "unique-slug": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-3.0.0.tgz", + "integrity": "sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==", + "requires": { + "imurmurhash": "^0.1.4" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "node-releases": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==", + "dev": true + }, + "nopt": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-6.0.0.tgz", + "integrity": "sha512-ZwLpbTgdhuZUnZzjd7nb1ZV+4DoiC6/sfiVKok72ym/4Tlf+DFdlHYmT2JPmcNNWV6Pi3SDf1kT+A4r9RTuT9g==", + "requires": { + "abbrev": "^1.0.0" + } + }, + "normalize-package-data": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-5.0.0.tgz", + "integrity": "sha512-h9iPVIfrVZ9wVYQnxFgtw1ugSvGEMOlyPWWtm8BMJhnwyEL/FLbYbTY3V3PpjI/BUK67n9PEWDu6eHzu1fB15Q==", + "requires": { + "hosted-git-info": "^6.0.0", + "is-core-module": "^2.8.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4" + }, + "dependencies": { + "hosted-git-info": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-6.1.1.tgz", + "integrity": "sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==", + "requires": { + "lru-cache": "^7.5.1" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + } + } + }, + "normalize-url": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.1.tgz", + "integrity": "sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w==" + }, + "npm": { + "version": "10.5.2", + "resolved": "https://registry.npmjs.org/npm/-/npm-10.5.2.tgz", + "integrity": "sha512-cHVG7QEJwJdZyOrK0dKX5uf3R5Fd0E8AcmSES1jLtO52UT1enUKZ96Onw/xwq4CbrTZEnDuu2Vf9kCQh/Sd12w==", + "requires": { + "@isaacs/string-locale-compare": "^1.1.0", + "@npmcli/arborist": "^7.2.1", + "@npmcli/config": "^8.0.2", + "@npmcli/fs": "^3.1.0", + "@npmcli/map-workspaces": "^3.0.6", + "@npmcli/package-json": "^5.0.2", + "@npmcli/promise-spawn": "^7.0.1", + "@npmcli/redact": "^1.1.0", + "@npmcli/run-script": "^7.0.4", + "@sigstore/tuf": "^2.3.2", + "abbrev": "^2.0.0", + "archy": "~1.0.0", + "cacache": "^18.0.2", + "chalk": "^5.3.0", + "ci-info": "^4.0.0", + "cli-columns": "^4.0.0", + "cli-table3": "^0.6.4", + "columnify": "^1.6.0", + "fastest-levenshtein": "^1.0.16", + "fs-minipass": "^3.0.3", + "glob": "^10.3.12", + "graceful-fs": "^4.2.11", + "hosted-git-info": "^7.0.1", + "ini": "^4.1.2", + "init-package-json": "^6.0.2", + "is-cidr": "^5.0.5", + "json-parse-even-better-errors": "^3.0.1", + "libnpmaccess": "^8.0.1", + "libnpmdiff": "^6.0.3", + "libnpmexec": "^7.0.4", + "libnpmfund": "^5.0.1", + "libnpmhook": "^10.0.0", + "libnpmorg": "^6.0.1", + "libnpmpack": "^6.0.3", + "libnpmpublish": "^9.0.2", + "libnpmsearch": "^7.0.0", + "libnpmteam": "^6.0.0", + "libnpmversion": "^5.0.1", + "make-fetch-happen": "^13.0.0", + "minimatch": "^9.0.4", + "minipass": "^7.0.4", + "minipass-pipeline": "^1.2.4", + "ms": "^2.1.2", + "node-gyp": "^10.1.0", + "nopt": "^7.2.0", + "normalize-package-data": "^6.0.0", + "npm-audit-report": "^5.0.0", + "npm-install-checks": "^6.3.0", + "npm-package-arg": "^11.0.1", + "npm-pick-manifest": "^9.0.0", + "npm-profile": "^9.0.0", + "npm-registry-fetch": "^16.2.0", + "npm-user-validate": "^2.0.0", + "npmlog": "^7.0.1", + "p-map": "^4.0.0", + "pacote": "^17.0.6", + "parse-conflict-json": "^3.0.1", + "proc-log": "^3.0.0", + "qrcode-terminal": "^0.12.0", + "read": "^3.0.1", + "semver": "^7.6.0", + "spdx-expression-parse": "^4.0.0", + "ssri": "^10.0.5", + "supports-color": "^9.4.0", + "tar": "^6.2.1", + "text-table": "~0.2.0", + "tiny-relative-date": "^1.3.0", + "treeverse": "^3.0.0", + "validate-npm-package-name": "^5.0.0", + "which": "^4.0.0", + "write-file-atomic": "^5.0.1" + }, + "dependencies": { + "@colors/colors": { + "version": "1.5.0", + "bundled": true, + "optional": true + }, + "@isaacs/cliui": { + "version": "8.0.2", + "bundled": true, + "requires": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "6.0.1", + "bundled": true + }, + "emoji-regex": { + "version": "9.2.2", + "bundled": true + }, + "string-width": { + "version": "5.1.2", + "bundled": true, + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + }, + "strip-ansi": { + "version": "7.1.0", + "bundled": true, + "requires": { + "ansi-regex": "^6.0.1" + } + } + } + }, + "@isaacs/string-locale-compare": { + "version": "1.1.0", + "bundled": true + }, + "@npmcli/agent": { + "version": "2.2.2", + "bundled": true, + "requires": { + "agent-base": "^7.1.0", + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.1", + "lru-cache": "^10.0.1", + "socks-proxy-agent": "^8.0.3" + } + }, + "@npmcli/arborist": { + "version": "7.4.2", + "bundled": true, + "requires": { + "@isaacs/string-locale-compare": "^1.1.0", + "@npmcli/fs": "^3.1.0", + "@npmcli/installed-package-contents": "^2.0.2", + "@npmcli/map-workspaces": "^3.0.2", + "@npmcli/metavuln-calculator": "^7.0.0", + "@npmcli/name-from-folder": "^2.0.0", + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.0.0", + "@npmcli/query": "^3.1.0", + "@npmcli/redact": "^1.1.0", + "@npmcli/run-script": "^7.0.2", + "bin-links": "^4.0.1", + "cacache": "^18.0.0", + "common-ancestor-path": "^1.0.1", + "hosted-git-info": "^7.0.1", + "json-parse-even-better-errors": "^3.0.0", + "json-stringify-nice": "^1.1.4", + "minimatch": "^9.0.4", + "nopt": "^7.0.0", + "npm-install-checks": "^6.2.0", + "npm-package-arg": "^11.0.1", + "npm-pick-manifest": "^9.0.0", + "npm-registry-fetch": "^16.2.0", + "npmlog": "^7.0.1", + "pacote": "^17.0.4", + "parse-conflict-json": "^3.0.0", + "proc-log": "^3.0.0", + "promise-all-reject-late": "^1.0.0", + "promise-call-limit": "^3.0.1", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.7", + "ssri": "^10.0.5", + "treeverse": "^3.0.0", + "walk-up-path": "^3.0.1" + } + }, + "@npmcli/config": { + "version": "8.2.2", + "bundled": true, + "requires": { + "@npmcli/map-workspaces": "^3.0.2", + "ci-info": "^4.0.0", + "ini": "^4.1.2", + "nopt": "^7.0.0", + "proc-log": "^3.0.0", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.5", + "walk-up-path": "^3.0.1" + } + }, + "@npmcli/disparity-colors": { + "version": "3.0.0", + "bundled": true, + "requires": { + "ansi-styles": "^4.3.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "bundled": true, + "requires": { + "color-convert": "^2.0.1" + } + } + } + }, + "@npmcli/fs": { + "version": "3.1.0", + "bundled": true, + "requires": { + "semver": "^7.3.5" + } + }, + "@npmcli/git": { + "version": "5.0.5", + "bundled": true, + "requires": { + "@npmcli/promise-spawn": "^7.0.0", + "lru-cache": "^10.0.1", + "npm-pick-manifest": "^9.0.0", + "proc-log": "^3.0.0", + "promise-inflight": "^1.0.1", + "promise-retry": "^2.0.1", + "semver": "^7.3.5", + "which": "^4.0.0" + } + }, + "@npmcli/installed-package-contents": { + "version": "2.0.2", + "bundled": true, + "requires": { + "npm-bundled": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + } + }, + "@npmcli/map-workspaces": { + "version": "3.0.6", + "bundled": true, + "requires": { + "@npmcli/name-from-folder": "^2.0.0", + "glob": "^10.2.2", + "minimatch": "^9.0.0", + "read-package-json-fast": "^3.0.0" + } + }, + "@npmcli/metavuln-calculator": { + "version": "7.0.0", + "bundled": true, + "requires": { + "cacache": "^18.0.0", + "json-parse-even-better-errors": "^3.0.0", + "pacote": "^17.0.0", + "semver": "^7.3.5" + } + }, + "@npmcli/name-from-folder": { + "version": "2.0.0", + "bundled": true + }, + "@npmcli/node-gyp": { + "version": "3.0.0", + "bundled": true + }, + "@npmcli/package-json": { + "version": "5.0.2", + "bundled": true, + "requires": { + "@npmcli/git": "^5.0.0", + "glob": "^10.2.2", + "hosted-git-info": "^7.0.0", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^6.0.0", + "proc-log": "^3.0.0", + "semver": "^7.5.3" + } + }, + "@npmcli/promise-spawn": { + "version": "7.0.1", + "bundled": true, + "requires": { + "which": "^4.0.0" + } + }, + "@npmcli/query": { + "version": "3.1.0", + "bundled": true, + "requires": { + "postcss-selector-parser": "^6.0.10" + } + }, + "@npmcli/redact": { + "version": "1.1.0", + "bundled": true + }, + "@npmcli/run-script": { + "version": "7.0.4", + "bundled": true, + "requires": { + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.0.0", + "@npmcli/promise-spawn": "^7.0.0", + "node-gyp": "^10.0.0", + "which": "^4.0.0" + } + }, + "@pkgjs/parseargs": { + "version": "0.11.0", + "bundled": true, + "optional": true + }, + "@sigstore/bundle": { + "version": "2.3.1", + "bundled": true, + "requires": { + "@sigstore/protobuf-specs": "^0.3.1" + } + }, + "@sigstore/core": { + "version": "1.1.0", + "bundled": true + }, + "@sigstore/protobuf-specs": { + "version": "0.3.1", + "bundled": true + }, + "@sigstore/sign": { + "version": "2.3.0", + "bundled": true, + "requires": { + "@sigstore/bundle": "^2.3.0", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.1", + "make-fetch-happen": "^13.0.0" + } + }, + "@sigstore/tuf": { + "version": "2.3.2", + "bundled": true, + "requires": { + "@sigstore/protobuf-specs": "^0.3.0", + "tuf-js": "^2.2.0" + } + }, + "@sigstore/verify": { + "version": "1.2.0", + "bundled": true, + "requires": { + "@sigstore/bundle": "^2.3.1", + "@sigstore/core": "^1.1.0", + "@sigstore/protobuf-specs": "^0.3.1" + } + }, + "@tufjs/canonical-json": { + "version": "2.0.0", + "bundled": true + }, + "@tufjs/models": { + "version": "2.0.0", + "bundled": true, + "requires": { + "@tufjs/canonical-json": "2.0.0", + "minimatch": "^9.0.3" + } + }, + "abbrev": { + "version": "2.0.0", + "bundled": true + }, + "agent-base": { + "version": "7.1.1", + "bundled": true, + "requires": { + "debug": "^4.3.4" + } + }, + "aggregate-error": { + "version": "3.1.0", + "bundled": true, + "requires": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + } + }, + "ansi-regex": { + "version": "5.0.1", + "bundled": true + }, + "ansi-styles": { + "version": "6.2.1", + "bundled": true + }, + "aproba": { + "version": "2.0.0", + "bundled": true + }, + "archy": { + "version": "1.0.0", + "bundled": true + }, + "are-we-there-yet": { + "version": "4.0.2", + "bundled": true + }, + "balanced-match": { + "version": "1.0.2", + "bundled": true + }, + "bin-links": { + "version": "4.0.3", + "bundled": true, + "requires": { + "cmd-shim": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "read-cmd-shim": "^4.0.0", + "write-file-atomic": "^5.0.0" + } + }, + "binary-extensions": { + "version": "2.3.0", + "bundled": true + }, + "brace-expansion": { + "version": "2.0.1", + "bundled": true, + "requires": { + "balanced-match": "^1.0.0" + } + }, + "builtins": { + "version": "5.1.0", + "bundled": true, + "requires": { + "semver": "^7.0.0" + } + }, + "cacache": { + "version": "18.0.2", + "bundled": true, + "requires": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^10.0.1", + "minipass": "^7.0.3", + "minipass-collect": "^2.0.1", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + } + }, + "chalk": { + "version": "5.3.0", + "bundled": true + }, + "chownr": { + "version": "2.0.0", + "bundled": true + }, + "ci-info": { + "version": "4.0.0", + "bundled": true + }, + "cidr-regex": { + "version": "4.0.5", + "bundled": true, + "requires": { + "ip-regex": "^5.0.0" + } + }, + "clean-stack": { + "version": "2.2.0", + "bundled": true + }, + "cli-columns": { + "version": "4.0.0", + "bundled": true, + "requires": { + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1" + } + }, + "cli-table3": { + "version": "0.6.4", + "bundled": true, + "requires": { + "@colors/colors": "1.5.0", + "string-width": "^4.2.0" + } + }, + "clone": { + "version": "1.0.4", + "bundled": true + }, + "cmd-shim": { + "version": "6.0.2", + "bundled": true + }, + "color-convert": { + "version": "2.0.1", + "bundled": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "bundled": true + }, + "color-support": { + "version": "1.1.3", + "bundled": true + }, + "columnify": { + "version": "1.6.0", + "bundled": true, + "requires": { + "strip-ansi": "^6.0.1", + "wcwidth": "^1.0.0" + } + }, + "common-ancestor-path": { + "version": "1.0.1", + "bundled": true + }, + "console-control-strings": { + "version": "1.1.0", + "bundled": true + }, + "cross-spawn": { + "version": "7.0.3", + "bundled": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "dependencies": { + "which": { + "version": "2.0.2", + "bundled": true, + "requires": { + "isexe": "^2.0.0" + } + } + } + }, + "cssesc": { + "version": "3.0.0", + "bundled": true + }, + "debug": { + "version": "4.3.4", + "bundled": true, + "requires": { + "ms": "2.1.2" + }, + "dependencies": { + "ms": { + "version": "2.1.2", + "bundled": true + } + } + }, + "defaults": { + "version": "1.0.4", + "bundled": true, + "requires": { + "clone": "^1.0.2" + } + }, + "diff": { + "version": "5.2.0", + "bundled": true + }, + "eastasianwidth": { + "version": "0.2.0", + "bundled": true + }, + "emoji-regex": { + "version": "8.0.0", + "bundled": true + }, + "encoding": { + "version": "0.1.13", + "bundled": true, + "optional": true, + "requires": { + "iconv-lite": "^0.6.2" + } + }, + "env-paths": { + "version": "2.2.1", + "bundled": true + }, + "err-code": { + "version": "2.0.3", + "bundled": true + }, + "exponential-backoff": { + "version": "3.1.1", + "bundled": true + }, + "fastest-levenshtein": { + "version": "1.0.16", + "bundled": true + }, + "foreground-child": { + "version": "3.1.1", + "bundled": true, + "requires": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + } + }, + "fs-minipass": { + "version": "3.0.3", + "bundled": true, + "requires": { + "minipass": "^7.0.3" + } + }, + "function-bind": { + "version": "1.1.2", + "bundled": true + }, + "gauge": { + "version": "5.0.1", + "bundled": true, + "requires": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.3", + "console-control-strings": "^1.1.0", + "has-unicode": "^2.0.1", + "signal-exit": "^4.0.1", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.5" + } + }, + "glob": { + "version": "10.3.12", + "bundled": true, + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.6", + "minimatch": "^9.0.1", + "minipass": "^7.0.4", + "path-scurry": "^1.10.2" + } + }, + "graceful-fs": { + "version": "4.2.11", + "bundled": true + }, + "has-unicode": { + "version": "2.0.1", + "bundled": true + }, + "hasown": { + "version": "2.0.2", + "bundled": true, + "requires": { + "function-bind": "^1.1.2" + } + }, + "hosted-git-info": { + "version": "7.0.1", + "bundled": true, + "requires": { + "lru-cache": "^10.0.1" + } + }, + "http-cache-semantics": { + "version": "4.1.1", + "bundled": true + }, + "http-proxy-agent": { + "version": "7.0.2", + "bundled": true, + "requires": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + } + }, + "https-proxy-agent": { + "version": "7.0.4", + "bundled": true, + "requires": { + "agent-base": "^7.0.2", + "debug": "4" + } + }, + "iconv-lite": { + "version": "0.6.3", + "bundled": true, + "optional": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + } + }, + "ignore-walk": { + "version": "6.0.4", + "bundled": true, + "requires": { + "minimatch": "^9.0.0" + } + }, + "imurmurhash": { + "version": "0.1.4", + "bundled": true + }, + "indent-string": { + "version": "4.0.0", + "bundled": true + }, + "ini": { + "version": "4.1.2", + "bundled": true + }, + "init-package-json": { + "version": "6.0.2", + "bundled": true, + "requires": { + "@npmcli/package-json": "^5.0.0", + "npm-package-arg": "^11.0.0", + "promzard": "^1.0.0", + "read": "^3.0.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4", + "validate-npm-package-name": "^5.0.0" + } + }, + "ip-address": { + "version": "9.0.5", + "bundled": true, + "requires": { + "jsbn": "1.1.0", + "sprintf-js": "^1.1.3" + }, + "dependencies": { + "sprintf-js": { + "version": "1.1.3", + "bundled": true + } + } + }, + "ip-regex": { + "version": "5.0.0", + "bundled": true + }, + "is-cidr": { + "version": "5.0.5", + "bundled": true, + "requires": { + "cidr-regex": "^4.0.4" + } + }, + "is-core-module": { + "version": "2.13.1", + "bundled": true, + "requires": { + "hasown": "^2.0.0" + } + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "bundled": true + }, + "is-lambda": { + "version": "1.0.1", + "bundled": true + }, + "isexe": { + "version": "2.0.0", + "bundled": true + }, + "jackspeak": { + "version": "2.3.6", + "bundled": true, + "requires": { + "@isaacs/cliui": "^8.0.2", + "@pkgjs/parseargs": "^0.11.0" + } + }, + "jsbn": { + "version": "1.1.0", + "bundled": true + }, + "json-parse-even-better-errors": { + "version": "3.0.1", + "bundled": true + }, + "json-stringify-nice": { + "version": "1.1.4", + "bundled": true + }, + "jsonparse": { + "version": "1.3.1", + "bundled": true + }, + "just-diff": { + "version": "6.0.2", + "bundled": true + }, + "just-diff-apply": { + "version": "5.5.0", + "bundled": true + }, + "libnpmaccess": { + "version": "8.0.3", + "bundled": true, + "requires": { + "npm-package-arg": "^11.0.1", + "npm-registry-fetch": "^16.2.0" + } + }, + "libnpmdiff": { + "version": "6.0.9", + "bundled": true, + "requires": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/disparity-colors": "^3.0.0", + "@npmcli/installed-package-contents": "^2.0.2", + "binary-extensions": "^2.3.0", + "diff": "^5.1.0", + "minimatch": "^9.0.4", + "npm-package-arg": "^11.0.1", + "pacote": "^17.0.4", + "tar": "^6.2.1" + } + }, + "libnpmexec": { + "version": "7.0.10", + "bundled": true, + "requires": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/run-script": "^7.0.2", + "ci-info": "^4.0.0", + "npm-package-arg": "^11.0.1", + "npmlog": "^7.0.1", + "pacote": "^17.0.4", + "proc-log": "^3.0.0", + "read": "^3.0.1", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.7", + "walk-up-path": "^3.0.1" + } + }, + "libnpmfund": { + "version": "5.0.7", + "bundled": true, + "requires": { + "@npmcli/arborist": "^7.2.1" + } + }, + "libnpmhook": { + "version": "10.0.2", + "bundled": true, + "requires": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + } + }, + "libnpmorg": { + "version": "6.0.3", + "bundled": true, + "requires": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + } + }, + "libnpmpack": { + "version": "6.0.9", + "bundled": true, + "requires": { + "@npmcli/arborist": "^7.2.1", + "@npmcli/run-script": "^7.0.2", + "npm-package-arg": "^11.0.1", + "pacote": "^17.0.4" + } + }, + "libnpmpublish": { + "version": "9.0.5", + "bundled": true, + "requires": { + "ci-info": "^4.0.0", + "normalize-package-data": "^6.0.0", + "npm-package-arg": "^11.0.1", + "npm-registry-fetch": "^16.2.0", + "proc-log": "^3.0.0", + "semver": "^7.3.7", + "sigstore": "^2.2.0", + "ssri": "^10.0.5" + } + }, + "libnpmsearch": { + "version": "7.0.2", + "bundled": true, + "requires": { + "npm-registry-fetch": "^16.2.0" + } + }, + "libnpmteam": { + "version": "6.0.2", + "bundled": true, + "requires": { + "aproba": "^2.0.0", + "npm-registry-fetch": "^16.2.0" + } + }, + "libnpmversion": { + "version": "5.0.2", + "bundled": true, + "requires": { + "@npmcli/git": "^5.0.3", + "@npmcli/run-script": "^7.0.2", + "json-parse-even-better-errors": "^3.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.7" + } + }, + "lru-cache": { + "version": "10.2.0", + "bundled": true + }, + "make-fetch-happen": { + "version": "13.0.0", + "bundled": true, + "requires": { + "@npmcli/agent": "^2.0.0", + "cacache": "^18.0.0", + "http-cache-semantics": "^4.1.1", + "is-lambda": "^1.0.1", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "ssri": "^10.0.0" + } + }, + "minimatch": { + "version": "9.0.4", + "bundled": true, + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "minipass": { + "version": "7.0.4", + "bundled": true + }, + "minipass-collect": { + "version": "2.0.1", + "bundled": true, + "requires": { + "minipass": "^7.0.3" + } + }, + "minipass-fetch": { + "version": "3.0.4", + "bundled": true, + "requires": { + "encoding": "^0.1.13", + "minipass": "^7.0.3", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + } + }, + "minipass-flush": { + "version": "1.0.5", + "bundled": true, + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "minipass-json-stream": { + "version": "1.0.1", + "bundled": true, + "requires": { + "jsonparse": "^1.3.1", + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "minipass-pipeline": { + "version": "1.2.4", + "bundled": true, + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "minipass-sized": { + "version": "1.0.3", + "bundled": true, + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "minizlib": { + "version": "2.1.2", + "bundled": true, + "requires": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "mkdirp": { + "version": "1.0.4", + "bundled": true + }, + "ms": { + "version": "2.1.3", + "bundled": true + }, + "mute-stream": { + "version": "1.0.0", + "bundled": true + }, + "negotiator": { + "version": "0.6.3", + "bundled": true + }, + "node-gyp": { + "version": "10.1.0", + "bundled": true, + "requires": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^10.3.10", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^13.0.0", + "nopt": "^7.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "tar": "^6.1.2", + "which": "^4.0.0" + } + }, + "nopt": { + "version": "7.2.0", + "bundled": true, + "requires": { + "abbrev": "^2.0.0" + } + }, + "normalize-package-data": { + "version": "6.0.0", + "bundled": true, + "requires": { + "hosted-git-info": "^7.0.0", + "is-core-module": "^2.8.1", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4" + } + }, + "npm-audit-report": { + "version": "5.0.0", + "bundled": true + }, + "npm-bundled": { + "version": "3.0.0", + "bundled": true, + "requires": { + "npm-normalize-package-bin": "^3.0.0" + } + }, + "npm-install-checks": { + "version": "6.3.0", + "bundled": true, + "requires": { + "semver": "^7.1.1" + } + }, + "npm-normalize-package-bin": { + "version": "3.0.1", + "bundled": true + }, + "npm-package-arg": { + "version": "11.0.1", + "bundled": true, + "requires": { + "hosted-git-info": "^7.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "validate-npm-package-name": "^5.0.0" + } + }, + "npm-packlist": { + "version": "8.0.2", + "bundled": true, + "requires": { + "ignore-walk": "^6.0.4" + } + }, + "npm-pick-manifest": { + "version": "9.0.0", + "bundled": true, + "requires": { + "npm-install-checks": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "npm-package-arg": "^11.0.0", + "semver": "^7.3.5" + } + }, + "npm-profile": { + "version": "9.0.0", + "bundled": true, + "requires": { + "npm-registry-fetch": "^16.0.0", + "proc-log": "^3.0.0" + } + }, + "npm-registry-fetch": { + "version": "16.2.0", + "bundled": true, + "requires": { + "@npmcli/redact": "^1.1.0", + "make-fetch-happen": "^13.0.0", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minipass-json-stream": "^1.0.1", + "minizlib": "^2.1.2", + "npm-package-arg": "^11.0.0", + "proc-log": "^3.0.0" + } + }, + "npm-user-validate": { + "version": "2.0.0", + "bundled": true + }, + "npmlog": { + "version": "7.0.1", + "bundled": true, + "requires": { + "are-we-there-yet": "^4.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^5.0.0", + "set-blocking": "^2.0.0" + } + }, + "p-map": { + "version": "4.0.0", + "bundled": true, + "requires": { + "aggregate-error": "^3.0.0" + } + }, + "pacote": { + "version": "17.0.6", + "bundled": true, + "requires": { + "@npmcli/git": "^5.0.0", + "@npmcli/installed-package-contents": "^2.0.1", + "@npmcli/promise-spawn": "^7.0.0", + "@npmcli/run-script": "^7.0.0", + "cacache": "^18.0.0", + "fs-minipass": "^3.0.0", + "minipass": "^7.0.2", + "npm-package-arg": "^11.0.0", + "npm-packlist": "^8.0.0", + "npm-pick-manifest": "^9.0.0", + "npm-registry-fetch": "^16.0.0", + "proc-log": "^3.0.0", + "promise-retry": "^2.0.1", + "read-package-json": "^7.0.0", + "read-package-json-fast": "^3.0.0", + "sigstore": "^2.2.0", + "ssri": "^10.0.0", + "tar": "^6.1.11" + } + }, + "parse-conflict-json": { + "version": "3.0.1", + "bundled": true, + "requires": { + "json-parse-even-better-errors": "^3.0.0", + "just-diff": "^6.0.0", + "just-diff-apply": "^5.2.0" + } + }, + "path-key": { + "version": "3.1.1", + "bundled": true + }, + "path-scurry": { + "version": "1.10.2", + "bundled": true, + "requires": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + } + }, + "postcss-selector-parser": { + "version": "6.0.16", + "bundled": true, + "requires": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + } + }, + "proc-log": { + "version": "3.0.0", + "bundled": true + }, + "promise-all-reject-late": { + "version": "1.0.1", + "bundled": true + }, + "promise-call-limit": { + "version": "3.0.1", + "bundled": true + }, + "promise-inflight": { + "version": "1.0.1", + "bundled": true + }, + "promise-retry": { + "version": "2.0.1", + "bundled": true, + "requires": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + } + }, + "promzard": { + "version": "1.0.1", + "bundled": true, + "requires": { + "read": "^3.0.1" + } + }, + "qrcode-terminal": { + "version": "0.12.0", + "bundled": true + }, + "read": { + "version": "3.0.1", + "bundled": true, + "requires": { + "mute-stream": "^1.0.0" + } + }, + "read-cmd-shim": { + "version": "4.0.0", + "bundled": true + }, + "read-package-json": { + "version": "7.0.0", + "bundled": true, + "requires": { + "glob": "^10.2.2", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0" + } + }, + "read-package-json-fast": { + "version": "3.0.2", + "bundled": true, + "requires": { + "json-parse-even-better-errors": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + } + }, + "retry": { + "version": "0.12.0", + "bundled": true + }, + "safer-buffer": { + "version": "2.1.2", + "bundled": true, + "optional": true + }, + "semver": { + "version": "7.6.0", + "bundled": true, + "requires": { + "lru-cache": "^6.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "6.0.0", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "set-blocking": { + "version": "2.0.0", + "bundled": true + }, + "shebang-command": { + "version": "2.0.0", + "bundled": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "bundled": true + }, + "signal-exit": { + "version": "4.1.0", + "bundled": true + }, + "sigstore": { + "version": "2.3.0", + "bundled": true, + "requires": { + "@sigstore/bundle": "^2.3.1", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.1", + "@sigstore/sign": "^2.3.0", + "@sigstore/tuf": "^2.3.1", + "@sigstore/verify": "^1.2.0" + } + }, + "smart-buffer": { + "version": "4.2.0", + "bundled": true + }, + "socks": { + "version": "2.8.3", + "bundled": true, + "requires": { + "ip-address": "^9.0.5", + "smart-buffer": "^4.2.0" + } + }, + "socks-proxy-agent": { + "version": "8.0.3", + "bundled": true, + "requires": { + "agent-base": "^7.1.1", + "debug": "^4.3.4", + "socks": "^2.7.1" + } + }, + "spdx-correct": { + "version": "3.2.0", + "bundled": true, + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + }, + "dependencies": { + "spdx-expression-parse": { + "version": "3.0.1", + "bundled": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + } + } + }, + "spdx-exceptions": { + "version": "2.5.0", + "bundled": true + }, + "spdx-expression-parse": { + "version": "4.0.0", + "bundled": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.17", + "bundled": true + }, + "ssri": { + "version": "10.0.5", + "bundled": true, + "requires": { + "minipass": "^7.0.3" + } + }, + "string-width": { + "version": "4.2.3", + "bundled": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "string-width-cjs": { + "version": "npm:string-width@4.2.3", + "bundled": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "strip-ansi": { + "version": "6.0.1", + "bundled": true, + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "strip-ansi-cjs": { + "version": "npm:strip-ansi@6.0.1", + "bundled": true, + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "supports-color": { + "version": "9.4.0", + "bundled": true + }, + "tar": { + "version": "6.2.1", + "bundled": true, + "requires": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "dependencies": { + "fs-minipass": { + "version": "2.1.0", + "bundled": true, + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "bundled": true, + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "minipass": { + "version": "5.0.0", + "bundled": true + } + } + }, + "text-table": { + "version": "0.2.0", + "bundled": true + }, + "tiny-relative-date": { + "version": "1.3.0", + "bundled": true + }, + "treeverse": { + "version": "3.0.0", + "bundled": true + }, + "tuf-js": { + "version": "2.2.0", + "bundled": true, + "requires": { + "@tufjs/models": "2.0.0", + "debug": "^4.3.4", + "make-fetch-happen": "^13.0.0" + } + }, + "unique-filename": { + "version": "3.0.0", + "bundled": true, + "requires": { + "unique-slug": "^4.0.0" + } + }, + "unique-slug": { + "version": "4.0.0", + "bundled": true, + "requires": { + "imurmurhash": "^0.1.4" + } + }, + "util-deprecate": { + "version": "1.0.2", + "bundled": true + }, + "validate-npm-package-license": { + "version": "3.0.4", + "bundled": true, + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + }, + "dependencies": { + "spdx-expression-parse": { + "version": "3.0.1", + "bundled": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + } + } + }, + "validate-npm-package-name": { + "version": "5.0.0", + "bundled": true, + "requires": { + "builtins": "^5.0.0" + } + }, + "walk-up-path": { + "version": "3.0.1", + "bundled": true + }, + "wcwidth": { + "version": "1.0.1", + "bundled": true, + "requires": { + "defaults": "^1.0.3" + } + }, + "which": { + "version": "4.0.0", + "bundled": true, + "requires": { + "isexe": "^3.1.1" + }, + "dependencies": { + "isexe": { + "version": "3.1.1", + "bundled": true + } + } + }, + "wide-align": { + "version": "1.1.5", + "bundled": true, + "requires": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "wrap-ansi": { + "version": "8.1.0", + "bundled": true, + "requires": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "dependencies": { + "ansi-regex": { + "version": "6.0.1", + "bundled": true + }, + "emoji-regex": { + "version": "9.2.2", + "bundled": true + }, + "string-width": { + "version": "5.1.2", + "bundled": true, + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + }, + "strip-ansi": { + "version": "7.1.0", + "bundled": true, + "requires": { + "ansi-regex": "^6.0.1" + } + } + } + }, + "wrap-ansi-cjs": { + "version": "npm:wrap-ansi@7.0.0", + "bundled": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "bundled": true, + "requires": { + "color-convert": "^2.0.1" + } + } + } + }, + "write-file-atomic": { + "version": "5.0.1", + "bundled": true, + "requires": { + "imurmurhash": "^0.1.4", + "signal-exit": "^4.0.1" + } + }, + "yallist": { + "version": "4.0.0", + "bundled": true + } + } + }, + "npm-bundled": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-3.0.0.tgz", + "integrity": "sha512-Vq0eyEQy+elFpzsKjMss9kxqb9tG3YHg4dsyWuUENuzvSUWe1TCnW/vV9FkhvBk/brEDoDiVd+M1Btosa6ImdQ==", + "requires": { + "npm-normalize-package-bin": "^3.0.0" + } + }, + "npm-check-updates": { + "version": "16.14.17", + "resolved": "https://registry.npmjs.org/npm-check-updates/-/npm-check-updates-16.14.17.tgz", + "integrity": "sha512-ElnDdXKe60f8S6RhzFeaGuH2TFJmt2cU2HjLdowldabdm27nWFCxV2ebeP3xGbQkzp2+RPDQNdW9HqU1lcY8ag==", + "requires": { + "chalk": "^5.3.0", + "cli-table3": "^0.6.3", + "commander": "^10.0.1", + "fast-memoize": "^2.5.2", + "find-up": "5.0.0", + "fp-and-or": "^0.1.4", + "get-stdin": "^8.0.0", + "globby": "^11.0.4", + "hosted-git-info": "^5.1.0", + "ini": "^4.1.1", + "js-yaml": "^4.1.0", + "json-parse-helpfulerror": "^1.0.3", + "jsonlines": "^0.1.1", + "lodash": "^4.17.21", + "make-fetch-happen": "^11.1.1", + "minimatch": "^9.0.3", + "p-map": "^4.0.0", + "pacote": "15.2.0", + "parse-github-url": "^1.0.2", + "progress": "^2.0.3", + "prompts-ncu": "^3.0.0", + "rc-config-loader": "^4.1.3", + "remote-git-tags": "^3.0.0", + "rimraf": "^5.0.5", + "semver": "^7.5.4", + "semver-utils": "^1.1.4", + "source-map-support": "^0.5.21", + "spawn-please": "^2.0.2", + "strip-ansi": "^7.1.0", + "strip-json-comments": "^5.0.1", + "untildify": "^4.0.0", + "update-notifier": "^6.0.2" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==" + }, + "find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "requires": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + } + }, + "glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + } + }, + "locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "requires": { + "p-locate": "^5.0.0" + } + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "requires": { + "yocto-queue": "^0.1.0" + } + }, + "p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "requires": { + "p-limit": "^3.0.2" + } + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==" + }, + "rimraf": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-5.0.5.tgz", + "integrity": "sha512-CqDakW+hMe/Bz202FPEymy68P+G50RfMQK+Qo5YUqc9SPipvbGjCGKd0RSKEelbsfQuw3g5NZDSrlZZAJurH1A==", + "requires": { + "glob": "^10.3.7" + } + } + } + }, + "npm-install-checks": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-6.3.0.tgz", + "integrity": "sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==", + "requires": { + "semver": "^7.1.1" + } + }, + "npm-normalize-package-bin": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-3.0.1.tgz", + "integrity": "sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==" + }, + "npm-package-arg": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-10.1.0.tgz", + "integrity": "sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==", + "requires": { + "hosted-git-info": "^6.0.0", + "proc-log": "^3.0.0", + "semver": "^7.3.5", + "validate-npm-package-name": "^5.0.0" + }, + "dependencies": { + "hosted-git-info": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-6.1.1.tgz", + "integrity": "sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==", + "requires": { + "lru-cache": "^7.5.1" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + } + } + }, + "npm-packlist": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-7.0.4.tgz", + "integrity": "sha512-d6RGEuRrNS5/N84iglPivjaJPxhDbZmlbTwTDX2IbcRHG5bZCdtysYMhwiPvcF4GisXHGn7xsxv+GQ7T/02M5Q==", + "requires": { + "ignore-walk": "^6.0.0" + } + }, + "npm-pick-manifest": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-8.0.2.tgz", + "integrity": "sha512-1dKY+86/AIiq1tkKVD3l0WI+Gd3vkknVGAggsFeBkTvbhMQ1OND/LKkYv4JtXPKUJ8bOTCyLiqEg2P6QNdK+Gg==", + "requires": { + "npm-install-checks": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "npm-package-arg": "^10.0.0", + "semver": "^7.3.5" + } + }, + "npm-registry-fetch": { + "version": "14.0.5", + "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-14.0.5.tgz", + "integrity": "sha512-kIDMIo4aBm6xg7jOttupWZamsZRkAqMqwqqbVXnUqstY5+tapvv6bkH/qMR76jdgV+YljEUCyWx3hRYMrJiAgA==", + "requires": { + "make-fetch-happen": "^11.0.0", + "minipass": "^5.0.0", + "minipass-fetch": "^3.0.0", + "minipass-json-stream": "^1.0.1", + "minizlib": "^2.1.2", + "npm-package-arg": "^10.0.0", + "proc-log": "^3.0.0" + } + }, + "npmlog": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz", + "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==", + "requires": { + "are-we-there-yet": "^3.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^4.0.3", + "set-blocking": "^2.0.0" + } + }, + "nth-check": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.2.tgz", + "integrity": "sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==", + "requires": { + "boolbase": "~1.0.0" + } + }, + "oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==" + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "p-cancelable": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz", + "integrity": "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==" + }, + "p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "requires": { + "aggregate-error": "^3.0.0" + } + }, + "package-json": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-8.1.1.tgz", + "integrity": "sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA==", + "requires": { + "got": "^12.1.0", + "registry-auth-token": "^5.0.1", + "registry-url": "^6.0.0", + "semver": "^7.3.7" + } + }, + "pacote": { + "version": "15.2.0", + "resolved": "https://registry.npmjs.org/pacote/-/pacote-15.2.0.tgz", + "integrity": "sha512-rJVZeIwHTUta23sIZgEIM62WYwbmGbThdbnkt81ravBplQv+HjyroqnLRNH2+sLJHcGZmLRmhPwACqhfTcOmnA==", + "requires": { + "@npmcli/git": "^4.0.0", + "@npmcli/installed-package-contents": "^2.0.1", + "@npmcli/promise-spawn": "^6.0.1", + "@npmcli/run-script": "^6.0.0", + "cacache": "^17.0.0", + "fs-minipass": "^3.0.0", + "minipass": "^5.0.0", + "npm-package-arg": "^10.0.0", + "npm-packlist": "^7.0.0", + "npm-pick-manifest": "^8.0.0", + "npm-registry-fetch": "^14.0.0", + "proc-log": "^3.0.0", + "promise-retry": "^2.0.1", + "read-package-json": "^6.0.0", + "read-package-json-fast": "^3.0.0", + "sigstore": "^1.3.0", + "ssri": "^10.0.0", + "tar": "^6.1.11" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "cacache": { + "version": "17.1.4", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.1.4.tgz", + "integrity": "sha512-/aJwG2l3ZMJ1xNAnqbMpA40of9dj/pIH3QfiuQSqjfPJF747VR0J/bHn+/KdNnHKc6XQcWt/AfRSBft82W1d2A==", + "requires": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^7.7.1", + "minipass": "^7.0.3", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "ssri": { + "version": "10.0.5", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.5.tgz", + "integrity": "sha512-bSf16tAFkGeRlUNDjXu8FzaMQt6g2HZJrun7mtMbIPOddxt3GLMSz5VWUWcqTJUPfLEaDIepGxv+bYQW49596A==", + "requires": { + "minipass": "^7.0.3" + }, + "dependencies": { + "minipass": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.0.4.tgz", + "integrity": "sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ==" + } + } + }, + "unique-filename": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", + "requires": { + "unique-slug": "^4.0.0" + } + }, + "unique-slug": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", + "requires": { + "imurmurhash": "^0.1.4" + } + } + } + }, + "parse-github-url": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/parse-github-url/-/parse-github-url-1.0.2.tgz", + "integrity": "sha512-kgBf6avCbO3Cn6+RnzRGLkUsv4ZVqv/VfAYkRsyBcgkshNvVBkRn1FEZcW0Jb+npXQWm2vHPnnOqFteZxRRGNw==" + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==" + }, + "path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "path-scurry": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.10.1.tgz", + "integrity": "sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==", + "requires": { + "lru-cache": "^9.1.1 || ^10.0.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.2.0.tgz", + "integrity": "sha512-2bIM8x+VAf6JT4bKAljS1qUWgMsqZRPGJS6FSahIMPVvctcNhyVp7AJu7quxOW9jwkryBReKZY5tY5JYv2n/7Q==" + } + } + }, + "path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==" + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==" + }, + "picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==" + }, + "proc-log": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-3.0.0.tgz", + "integrity": "sha512-++Vn7NS4Xf9NacaU9Xq3URUuqZETPsf8L4j5/ckhaRYsfPeRyzGw+iDjFhV/Jr3uNmTvvddEJFWh5R1gRgUH8A==" + }, + "progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==" + }, + "promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha1-mEcocL8igTL8vdhoEputEsPAKeM=" + }, + "promise-retry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", + "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", + "requires": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + } + }, + "prompts-ncu": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/prompts-ncu/-/prompts-ncu-3.0.0.tgz", + "integrity": "sha512-qyz9UxZ5MlPKWVhWrCmSZ1ahm2GVYdjLb8og2sg0IPth1KRuhcggHGuijz0e41dkx35p1t1q3GRISGH7QGALFA==", + "requires": { + "kleur": "^4.0.1", + "sisteransi": "^1.0.5" + } + }, + "proto-list": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", + "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==" + }, + "psl": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz", + "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==" + }, + "pupa": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/pupa/-/pupa-3.1.0.tgz", + "integrity": "sha512-FLpr4flz5xZTSJxSeaheeMKN/EDzMdK7b8PTOC6a5PYFKTucWbdqjgqaEyH0shFiSJrVB1+Qqi4Tk19ccU6Aug==", + "requires": { + "escape-goat": "^4.0.0" + } + }, + "qs": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz", + "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==" + }, + "queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==" + }, + "quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==" + }, + "randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "raw-loader": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/raw-loader/-/raw-loader-0.5.1.tgz", + "integrity": "sha1-DD0L6u2KAclm2Xh793goElKpeao=", + "dev": true + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "requires": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "dependencies": { + "ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==" + } + } + }, + "rc-config-loader": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/rc-config-loader/-/rc-config-loader-4.1.3.tgz", + "integrity": "sha512-kD7FqML7l800i6pS6pvLyIE2ncbk9Du8Q0gp/4hMPhJU6ZxApkoLcGD8ZeqgiAlfwZ6BlETq6qqe+12DUL207w==", + "requires": { + "debug": "^4.3.4", + "js-yaml": "^4.1.0", + "json5": "^2.2.2", + "require-from-string": "^2.0.2" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "read-package-json": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/read-package-json/-/read-package-json-6.0.4.tgz", + "integrity": "sha512-AEtWXYfopBj2z5N5PbkAOeNHRPUg5q+Nen7QLxV8M2zJq1ym6/lCz3fYNTCXe19puu2d06jfHhrP7v/S2PtMMw==", + "requires": { + "glob": "^10.2.2", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^5.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "glob": { + "version": "10.3.10", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz", + "integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==", + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^2.3.5", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + } + }, + "minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "requires": { + "brace-expansion": "^2.0.1" + } + } + } + }, + "read-package-json-fast": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/read-package-json-fast/-/read-package-json-fast-3.0.2.tgz", + "integrity": "sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==", + "requires": { + "json-parse-even-better-errors": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + } + }, + "rechoir": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz", + "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==", + "dev": true, + "requires": { + "resolve": "^1.20.0" + } + }, + "registry-auth-token": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.0.2.tgz", + "integrity": "sha512-o/3ikDxtXaA59BmZuZrJZDJv8NMDGSj+6j6XaeBmHw8eY1i1qd9+6H+LjVvQXx3HN6aRCGa1cUdJ9RaJZUugnQ==", + "requires": { + "@pnpm/npm-conf": "^2.1.0" + } + }, + "registry-url": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-6.0.1.tgz", + "integrity": "sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==", + "requires": { + "rc": "1.2.8" + } + }, + "remote-git-tags": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/remote-git-tags/-/remote-git-tags-3.0.0.tgz", + "integrity": "sha512-C9hAO4eoEsX+OXA4rla66pXZQ+TLQ8T9dttgQj18yuKlPMTVkIkdYXvlMC55IuUsIkV6DpmQYi10JKFLaU+l7w==" + }, + "request": { + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "requires": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.5.0", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + }, + "dependencies": { + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==" + } + } + }, + "require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==" + }, + "resolve": { + "version": "1.22.8", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz", + "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==", + "dev": true, + "requires": { + "is-core-module": "^2.13.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + } + }, + "resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==" + }, + "resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "requires": { + "resolve-from": "^5.0.0" + } + }, + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + }, + "responselike": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz", + "integrity": "sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==", + "requires": { + "lowercase-keys": "^3.0.0" + } + }, + "retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==" + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==" + }, + "run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "schema-utils": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + } + }, + "script-loader": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/script-loader/-/script-loader-0.7.2.tgz", + "integrity": "sha512-UMNLEvgOAQuzK8ji8qIscM3GIrRCWN6MmMXGD4SD5l6cSycgGsCo0tX5xRnfQcoghqct0tjHjcykgI1PyBE2aA==", + "dev": true, + "requires": { + "raw-loader": "~0.5.1" + } + }, + "semver": { + "version": "7.6.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.0.tgz", + "integrity": "sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==", + "requires": { + "lru-cache": "^6.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "semver-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-4.0.0.tgz", + "integrity": "sha512-0Ju4+6A8iOnpL/Thra7dZsSlOHYAHIeMxfhWQRI1/VLcT3WDBZKKtQt/QkBOsiIN9ZpuvHE6cGZ0x4glCMmfiA==", + "requires": { + "semver": "^7.3.5" + } + }, + "semver-utils": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/semver-utils/-/semver-utils-1.1.4.tgz", + "integrity": "sha512-EjnoLE5OGmDAVV/8YDoN5KiajNadjzIp9BAHOhYeQHt7j0UWxjmgsx4YD48wp4Ue1Qogq38F1GNUJNqF1kKKxA==" + }, + "serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "dev": true, + "requires": { + "randombytes": "^2.1.0" + } + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==" + }, + "shallow-clone": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz", + "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==", + "dev": true, + "requires": { + "kind-of": "^6.0.2" + } + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==" + }, + "signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + }, + "sigstore": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/sigstore/-/sigstore-1.9.0.tgz", + "integrity": "sha512-0Zjz0oe37d08VeOtBIuB6cRriqXse2e8w+7yIy2XSXjshRKxbc2KkhXjL229jXSxEm7UbcjS76wcJDGQddVI9A==", + "requires": { + "@sigstore/bundle": "^1.1.0", + "@sigstore/protobuf-specs": "^0.2.0", + "@sigstore/sign": "^1.0.0", + "@sigstore/tuf": "^1.0.3", + "make-fetch-happen": "^11.0.1" + } + }, + "sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==" + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==" + }, + "smart-buffer": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", + "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==" + }, + "socks": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.1.tgz", + "integrity": "sha512-B6w7tkwNid7ToxjZ08rQMT8M9BJAf8DKx8Ft4NivzH0zBUfd6jldGcisJn/RLgxcX3FPNDdNQCUEMMT79b+oCQ==", + "requires": { + "ip-address": "^9.0.5", + "smart-buffer": "^4.2.0" + } + }, + "socks-proxy-agent": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-7.0.0.tgz", + "integrity": "sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==", + "requires": { + "agent-base": "^6.0.2", + "debug": "^4.3.3", + "socks": "^2.6.2" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + } + } + }, + "spawn-please": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/spawn-please/-/spawn-please-2.0.2.tgz", + "integrity": "sha512-KM8coezO6ISQ89c1BzyWNtcn2V2kAVtwIXd3cN/V5a0xPYc1F/vydrRc01wsKFEQ/p+V1a4sw4z2yMITIXrgGw==", + "requires": { + "cross-spawn": "^7.0.3" + } + }, + "spdx-correct": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", + "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", + "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==" + }, + "spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.17", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.17.tgz", + "integrity": "sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==" + }, + "sprintf-js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", + "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==" + }, + "sshpk": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.18.0.tgz", + "integrity": "sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==", + "requires": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "~5.1.0" + } + }, + "string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + } + } + } + }, + "string-width-cjs": { + "version": "npm:string-width@4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + } + } + } + }, + "strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "requires": { + "ansi-regex": "^6.0.1" + } + }, + "strip-ansi-cjs": { + "version": "npm:strip-ansi@6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + } + } + }, + "strip-json-comments": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.1.tgz", + "integrity": "sha512-0fk9zBqO67Nq5M/m45qHCJxylV/DhBlIOVExqgOMiCCrzrhU6tCibRXNqE3jwJLftzE9SNuZtYbpzcO+i9FiKw==" + }, + "supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + }, + "supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true + }, + "tapable": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", + "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "dev": true + }, + "tar": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", + "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", + "requires": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "dependencies": { + "chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==" + }, + "fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==" + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "terser": { + "version": "5.29.2", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.29.2.tgz", + "integrity": "sha512-ZiGkhUBIM+7LwkNjXYJq8svgkd+QK3UUr0wJqY4MieaezBSAIPgbSPZyIx0idM6XWK5CMzSWa8MJIzmRcB8Caw==", + "dev": true, + "requires": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + } + }, + "terser-webpack-plugin": { + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz", + "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "^0.3.20", + "jest-worker": "^27.4.5", + "schema-utils": "^3.1.1", + "serialize-javascript": "^6.0.1", + "terser": "^5.26.0" + } + }, + "tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "requires": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + }, + "dependencies": { + "punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==" + } + } + }, + "tuf-js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-1.1.7.tgz", + "integrity": "sha512-i3P9Kgw3ytjELUfpuKVDNBJvk4u5bXL6gskv572mcevPbSKCV3zt3djhmlEQ65yERjIbOSncy7U4cQJaB1CBCg==", + "requires": { + "@tufjs/models": "1.0.4", + "debug": "^4.3.4", + "make-fetch-happen": "^11.1.1" + }, + "dependencies": { + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + } + } + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==" + }, + "type-fest": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", + "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==" + }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "requires": { + "is-typedarray": "^1.0.0" + } + }, + "undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true + }, + "unique-string": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-3.0.0.tgz", + "integrity": "sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==", + "requires": { + "crypto-random-string": "^4.0.0" + } + }, + "untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==" + }, + "update-browserslist-db": { + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", + "dev": true, + "requires": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + } + }, + "update-notifier": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-6.0.2.tgz", + "integrity": "sha512-EDxhTEVPZZRLWYcJ4ZXjGFN0oP7qYvbXWzEgRm/Yql4dHX5wDbvh89YHP6PK1lzZJYrMtXUuZZz8XGK+U6U1og==", + "requires": { + "boxen": "^7.0.0", + "chalk": "^5.0.1", + "configstore": "^6.0.0", + "has-yarn": "^3.0.0", + "import-lazy": "^4.0.0", + "is-ci": "^3.0.1", + "is-installed-globally": "^0.4.0", + "is-npm": "^6.0.0", + "is-yarn-global": "^0.4.0", + "latest-version": "^7.0.0", + "pupa": "^3.1.0", + "semver": "^7.3.7", + "semver-diff": "^4.0.0", + "xdg-basedir": "^5.1.0" + } + }, + "uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "requires": { + "punycode": "^2.1.0" + }, + "dependencies": { + "punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==" + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "uuid": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", + "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==" + }, + "validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "validate-npm-package-name": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.0.tgz", + "integrity": "sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==", + "requires": { + "builtins": "^5.0.0" + } + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==", + "requires": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "watchpack": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.1.tgz", + "integrity": "sha512-8wrBCMtVhqcXP2Sup1ctSkga6uc2Bx0IIvKyT7yTFier5AXHooSI+QyQQAtTb7+E0IUCCKyTFmXqdqgum2XWGg==", + "dev": true, + "requires": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + } + }, + "webpack": { + "version": "5.90.3", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.90.3.tgz", + "integrity": "sha512-h6uDYlWCctQRuXBs1oYpVe6sFcWedl0dpcVaTf/YF67J9bKvwJajFulMVSYKHrksMB3I/pIagRzDxwxkebuzKA==", + "dev": true, + "requires": { + "@types/eslint-scope": "^3.7.3", + "@types/estree": "^1.0.5", + "@webassemblyjs/ast": "^1.11.5", + "@webassemblyjs/wasm-edit": "^1.11.5", + "@webassemblyjs/wasm-parser": "^1.11.5", + "acorn": "^8.7.1", + "acorn-import-assertions": "^1.9.0", + "browserslist": "^4.21.10", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.15.0", + "es-module-lexer": "^1.2.1", + "eslint-scope": "5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.9", + "json-parse-even-better-errors": "^2.3.1", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^3.2.0", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.3.10", + "watchpack": "^2.4.0", + "webpack-sources": "^3.2.3" + }, + "dependencies": { + "json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + } + } + }, + "webpack-cli": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-5.1.4.tgz", + "integrity": "sha512-pIDJHIEI9LR0yxHXQ+Qh95k2EvXpWzZ5l+d+jIo+RdSm9MiHfzazIxwwni/p7+x4eJZuvG1AJwgC4TNQ7NRgsg==", + "dev": true, + "requires": { + "@discoveryjs/json-ext": "^0.5.0", + "@webpack-cli/configtest": "^2.1.1", + "@webpack-cli/info": "^2.0.2", + "@webpack-cli/serve": "^2.0.5", + "colorette": "^2.0.14", + "commander": "^10.0.1", + "cross-spawn": "^7.0.3", + "envinfo": "^7.7.3", + "fastest-levenshtein": "^1.0.12", + "import-local": "^3.0.2", + "interpret": "^3.1.1", + "rechoir": "^0.8.0", + "webpack-merge": "^5.7.3" + }, + "dependencies": { + "@webpack-cli/configtest": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-2.1.1.tgz", + "integrity": "sha512-wy0mglZpDSiSS0XHrVR+BAdId2+yxPSoJW8fsna3ZpYSlufjvxnP4YbKTCBZnNIcGN4r6ZPXV55X4mYExOfLmw==", + "dev": true, + "requires": {} + }, + "@webpack-cli/info": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-2.0.2.tgz", + "integrity": "sha512-zLHQdI/Qs1UyT5UBdWNqsARasIA+AaF8t+4u2aS2nEpBQh2mWIVb8qAklq0eUENnC5mOItrIB4LiS9xMtph18A==", + "dev": true, + "requires": {} + }, + "@webpack-cli/serve": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-2.0.5.tgz", + "integrity": "sha512-lqaoKnRYBdo1UgDX8uF24AfGMifWK19TxPmM5FHc2vAGxrJ/qtyUyFBWoY1tISZdelsQ5fBcOusifo5o5wSJxQ==", + "dev": true, + "requires": {} + }, + "commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true + } + } + }, + "webpack-merge": { + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz", + "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==", + "dev": true, + "requires": { + "clone-deep": "^4.0.1", + "flat": "^5.0.2", + "wildcard": "^2.0.0" + } + }, + "webpack-sources": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz", + "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==", + "dev": true + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "requires": { + "isexe": "^2.0.0" + } + }, + "wide-align": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", + "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "requires": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "widest-line": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-4.0.1.tgz", + "integrity": "sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==", + "requires": { + "string-width": "^5.0.1" + }, + "dependencies": { + "emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + } + } + }, + "wildcard": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz", + "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==", + "dev": true + }, + "wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "requires": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "dependencies": { + "emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + } + } + }, + "wrap-ansi-cjs": { + "version": "npm:wrap-ansi@7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "requires": { + "color-convert": "^2.0.1" + } + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + } + } + } + }, + "wrapper-webpack-plugin": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/wrapper-webpack-plugin/-/wrapper-webpack-plugin-2.2.2.tgz", + "integrity": "sha512-twLGZw0b2AEnz3LmsM/uCFRzGxE+XUlUPlJkCuHY3sI+uGO4dTJsgYee3ufWJaynAZYkpgQSKMSr49n9Yxalzg==", + "dev": true, + "requires": {} + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write-file-atomic": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", + "requires": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "xdg-basedir": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-5.1.0.tgz", + "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==" + }, + "yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==" + } + } +} diff --git a/seminar06-planning/simulator/package.json b/seminar06-planning/simulator/package.json new file mode 100644 index 0000000..fd569d4 --- /dev/null +++ b/seminar06-planning/simulator/package.json @@ -0,0 +1,22 @@ +{ + "name": "dash", + "version": "1.0.0", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1", + "build": "webpack", + "watch": "webpack --watch" + }, + "author": "Matt Bradley", + "license": "MIT", + "devDependencies": { + "script-loader": "^0.7.2", + "webpack": "^5.90.3", + "webpack-cli": "^5.1.4", + "wrapper-webpack-plugin": "2.2.2" + }, + "dependencies": { + "ncu": "^0.2.1", + "npm": "^10.5.2", + "npm-check-updates": "^16.14.17" + } +} diff --git a/seminar06-planning/simulator/vendor/THREE.MeshLine.js b/seminar06-planning/simulator/vendor/THREE.MeshLine.js new file mode 100644 index 0000000..30cd068 --- /dev/null +++ b/seminar06-planning/simulator/vendor/THREE.MeshLine.js @@ -0,0 +1,477 @@ +;(function() { + +"use strict"; + +var root = this + +var has_require = typeof require !== 'undefined' + +var THREE = root.THREE || has_require && require('three') +if( !THREE ) + throw new Error( 'MeshLine requires three.js' ) + +function MeshLine() { + + this.positions = []; + + this.previous = []; + this.next = []; + this.side = []; + this.width = []; + this.indices_array = []; + this.uvs = []; + this.counters = []; + this.geometry = new THREE.BufferGeometry(); + + this.widthCallback = null; + +} + +MeshLine.prototype.setGeometry = function( g, c ) { + + this.widthCallback = c; + + this.positions = []; + this.counters = []; + + if( g instanceof THREE.Geometry ) { + for( var j = 0; j < g.vertices.length; j++ ) { + var v = g.vertices[ j ]; + var c = j/g.vertices.length; + this.positions.push( v.x, v.y, v.z ); + this.positions.push( v.x, v.y, v.z ); + this.counters.push(c); + this.counters.push(c); + } + } + + if( g instanceof THREE.BufferGeometry ) { + // read attribute positions ? + } + + if( g instanceof Float32Array || g instanceof Array ) { + for( var j = 0; j < g.length; j += 3 ) { + var c = j/g.length; + this.positions.push( g[ j ], g[ j + 1 ], g[ j + 2 ] ); + this.positions.push( g[ j ], g[ j + 1 ], g[ j + 2 ] ); + this.counters.push(c); + this.counters.push(c); + } + } + + this.process(); + +} + +MeshLine.prototype.compareV3 = function( a, b ) { + + var aa = a * 6; + var ab = b * 6; + return ( this.positions[ aa ] === this.positions[ ab ] ) && ( this.positions[ aa + 1 ] === this.positions[ ab + 1 ] ) && ( this.positions[ aa + 2 ] === this.positions[ ab + 2 ] ); + +} + +MeshLine.prototype.copyV3 = function( a ) { + + var aa = a * 6; + return [ this.positions[ aa ], this.positions[ aa + 1 ], this.positions[ aa + 2 ] ]; + +} + +MeshLine.prototype.process = function() { + + var l = this.positions.length / 6; + + this.previous = []; + this.next = []; + this.side = []; + this.width = []; + this.indices_array = []; + this.uvs = []; + + for( var j = 0; j < l; j++ ) { + this.side.push( 1 ); + this.side.push( -1 ); + } + + var w; + for( var j = 0; j < l; j++ ) { + if( this.widthCallback ) w = this.widthCallback( j / ( l -1 ) ); + else w = 1; + this.width.push( w ); + this.width.push( w ); + } + + for( var j = 0; j < l; j++ ) { + this.uvs.push( j / ( l - 1 ), 0 ); + this.uvs.push( j / ( l - 1 ), 1 ); + } + + var v; + + if( this.compareV3( 0, l - 1 ) ){ + v = this.copyV3( l - 2 ); + } else { + v = this.copyV3( 0 ); + } + this.previous.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + this.previous.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + for( var j = 0; j < l - 1; j++ ) { + v = this.copyV3( j ); + this.previous.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + this.previous.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + } + + for( var j = 1; j < l; j++ ) { + v = this.copyV3( j ); + this.next.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + this.next.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + } + + if( this.compareV3( l - 1, 0 ) ){ + v = this.copyV3( 1 ); + } else { + v = this.copyV3( l - 1 ); + } + this.next.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + this.next.push( v[ 0 ], v[ 1 ], v[ 2 ] ); + + for( var j = 0; j < l - 1; j++ ) { + var n = j * 2; + this.indices_array.push( n, n + 1, n + 2 ); + this.indices_array.push( n + 2, n + 1, n + 3 ); + } + + if (!this.attributes) { + this.attributes = { + position: new THREE.BufferAttribute( new Float32Array( this.positions ), 3 ), + previous: new THREE.BufferAttribute( new Float32Array( this.previous ), 3 ), + next: new THREE.BufferAttribute( new Float32Array( this.next ), 3 ), + side: new THREE.BufferAttribute( new Float32Array( this.side ), 1 ), + width: new THREE.BufferAttribute( new Float32Array( this.width ), 1 ), + uv: new THREE.BufferAttribute( new Float32Array( this.uvs ), 2 ), + index: new THREE.BufferAttribute( new Uint16Array( this.indices_array ), 1 ), + counters: new THREE.BufferAttribute( new Float32Array( this.counters ), 1 ) + } + } else { + this.attributes.position.copyArray(new Float32Array(this.positions)); + this.attributes.position.needsUpdate = true; + this.attributes.previous.copyArray(new Float32Array(this.previous)); + this.attributes.previous.needsUpdate = true; + this.attributes.next.copyArray(new Float32Array(this.next)); + this.attributes.next.needsUpdate = true; + this.attributes.side.copyArray(new Float32Array(this.side)); + this.attributes.side.needsUpdate = true; + this.attributes.width.copyArray(new Float32Array(this.width)); + this.attributes.width.needsUpdate = true; + this.attributes.uv.copyArray(new Float32Array(this.uvs)); + this.attributes.uv.needsUpdate = true; + this.attributes.index.copyArray(new Uint16Array(this.indices_array)); + this.attributes.index.needsUpdate = true; + } + + this.geometry.addAttribute( 'position', this.attributes.position ); + this.geometry.addAttribute( 'previous', this.attributes.previous ); + this.geometry.addAttribute( 'next', this.attributes.next ); + this.geometry.addAttribute( 'side', this.attributes.side ); + this.geometry.addAttribute( 'width', this.attributes.width ); + this.geometry.addAttribute( 'uv', this.attributes.uv ); + this.geometry.addAttribute( 'counters', this.attributes.counters ); + + this.geometry.setIndex( this.attributes.index ); + +} + +function memcpy (src, srcOffset, dst, dstOffset, length) { + var i + + src = src.subarray || src.slice ? src : src.buffer + dst = dst.subarray || dst.slice ? dst : dst.buffer + + src = srcOffset ? src.subarray ? + src.subarray(srcOffset, length && srcOffset + length) : + src.slice(srcOffset, length && srcOffset + length) : src + + if (dst.set) { + dst.set(src, dstOffset) + } else { + for (i=0; i.control{-ms-flex-negative:0;flex-shrink:0}.field.is-grouped>.control:not(:last-child){margin-bottom:0;margin-right:.75rem}.field.is-grouped>.control.is-expanded{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}.field.is-grouped.is-grouped-centered{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.field.is-grouped.is-grouped-right{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end}.field.is-grouped.is-grouped-multiline{-ms-flex-wrap:wrap;flex-wrap:wrap}.field.is-grouped.is-grouped-multiline>.control:last-child,.field.is-grouped.is-grouped-multiline>.control:not(:last-child){margin-bottom:.75rem}.field.is-grouped.is-grouped-multiline:last-child{margin-bottom:-.75rem}.field.is-grouped.is-grouped-multiline:not(:last-child){margin-bottom:0}@media screen and (min-width:769px),print{.field.is-horizontal{display:-webkit-box;display:-ms-flexbox;display:flex}}.field-label .label{font-size:inherit}@media screen and (max-width:768px){.field-label{margin-bottom:.5rem}}@media screen and (min-width:769px),print{.field-label{-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;margin-right:1.5rem;text-align:right}.field-label.is-small{font-size:.75rem;padding-top:.375em}.field-label.is-normal{padding-top:.375em}.field-label.is-medium{font-size:1.25rem;padding-top:.375em}.field-label.is-large{font-size:1.5rem;padding-top:.375em}}.field-body .field .field{margin-bottom:0}@media screen and (min-width:769px),print{.field-body{display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:5;-ms-flex-positive:5;flex-grow:5;-ms-flex-negative:1;flex-shrink:1}.field-body .field{margin-bottom:0}.field-body>.field{-ms-flex-negative:1;flex-shrink:1}.field-body>.field:not(.is-narrow){-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1}.field-body>.field:not(:last-child){margin-right:.75rem}}.control{font-size:1rem;position:relative;text-align:left}.control.has-icon .icon{color:#dbdbdb;height:2.25em;pointer-events:none;position:absolute;top:0;width:2.25em;z-index:4}.control.has-icon .input:focus+.icon{color:#7a7a7a}.control.has-icon .input.is-small+.icon{font-size:.75rem}.control.has-icon .input.is-medium+.icon{font-size:1.25rem}.control.has-icon .input.is-large+.icon{font-size:1.5rem}.control.has-icon:not(.has-icon-right) .icon{left:0}.control.has-icon:not(.has-icon-right) .input{padding-left:2.25em}.control.has-icon.has-icon-right .icon{right:0}.control.has-icon.has-icon-right .input{padding-right:2.25em}.control.has-icons-left .input:focus~.icon,.control.has-icons-left .select:focus~.icon,.control.has-icons-right .input:focus~.icon,.control.has-icons-right .select:focus~.icon{color:#7a7a7a}.control.has-icons-left .input.is-small~.icon,.control.has-icons-left .select.is-small~.icon,.control.has-icons-right .input.is-small~.icon,.control.has-icons-right .select.is-small~.icon{font-size:.75rem}.control.has-icons-left .input.is-medium~.icon,.control.has-icons-left .select.is-medium~.icon,.control.has-icons-right .input.is-medium~.icon,.control.has-icons-right .select.is-medium~.icon{font-size:1.25rem}.control.has-icons-left .input.is-large~.icon,.control.has-icons-left .select.is-large~.icon,.control.has-icons-right .input.is-large~.icon,.control.has-icons-right .select.is-large~.icon{font-size:1.5rem}.control.has-icons-left .icon,.control.has-icons-right .icon{color:#dbdbdb;height:2.25em;pointer-events:none;position:absolute;top:0;width:2.25em;z-index:4}.control.has-icons-left .input,.control.has-icons-left .select select{padding-left:2.25em}.control.has-icons-left .icon.is-left{left:0}.control.has-icons-right .input,.control.has-icons-right .select select{padding-right:2.25em}.control.has-icons-right .icon.is-right{right:0}.control.is-loading::after{-webkit-animation:spinAround .5s infinite linear;animation:spinAround .5s infinite linear;border:2px solid #dbdbdb;border-radius:290486px;border-right-color:transparent;border-top-color:transparent;content:"";display:block;height:1em;position:relative;width:1em;position:absolute!important;right:.625em;top:.625em;z-index:4}.control.is-loading.is-small:after{font-size:.75rem}.control.is-loading.is-medium:after{font-size:1.25rem}.control.is-loading.is-large:after{font-size:1.5rem}.icon{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;height:1.5rem;width:1.5rem}.icon.is-small{height:1rem;width:1rem}.icon.is-medium{height:2rem;width:2rem}.icon.is-large{height:3rem;width:3rem}.image{display:block;position:relative}.image img{display:block;height:auto;width:100%}.image img.is-rounded{border-radius:290486px}.image.is-16by9 img,.image.is-1by1 img,.image.is-2by1 img,.image.is-3by2 img,.image.is-4by3 img,.image.is-square img{bottom:0;left:0;position:absolute;right:0;top:0;height:100%;width:100%}.image.is-1by1,.image.is-square{padding-top:100%}.image.is-4by3{padding-top:75%}.image.is-3by2{padding-top:66.6666%}.image.is-16by9{padding-top:56.25%}.image.is-2by1{padding-top:50%}.image.is-16x16{height:16px;width:16px}.image.is-24x24{height:24px;width:24px}.image.is-32x32{height:32px;width:32px}.image.is-48x48{height:48px;width:48px}.image.is-64x64{height:64px;width:64px}.image.is-96x96{height:96px;width:96px}.image.is-128x128{height:128px;width:128px}.notification{background-color:#f5f5f5;border-radius:3px;padding:1.25rem 2.5rem 1.25rem 1.5rem;position:relative}.notification:not(:last-child){margin-bottom:1.5rem}.notification a:not(.button){color:currentColor;text-decoration:underline}.notification strong{color:currentColor}.notification code,.notification pre{background:#fff}.notification pre code{background:0 0}.notification>.delete{position:absolute;right:.5rem;top:.5rem}.notification .content,.notification .subtitle,.notification .title{color:currentColor}.notification.is-white{background-color:#fff;color:#0a0a0a}.notification.is-black{background-color:#0a0a0a;color:#fff}.notification.is-light{background-color:#f5f5f5;color:#363636}.notification.is-dark{background-color:#363636;color:#f5f5f5}.notification.is-primary{background-color:#00d1b2;color:#fff}.notification.is-link{background-color:#3273dc;color:#fff}.notification.is-info{background-color:#209cee;color:#fff}.notification.is-success{background-color:#23d160;color:#fff}.notification.is-warning{background-color:#ffdd57;color:rgba(0,0,0,.7)}.notification.is-danger{background-color:#ff3860;color:#fff}.progress{-moz-appearance:none;-webkit-appearance:none;border:none;border-radius:290486px;display:block;height:1rem;overflow:hidden;padding:0;width:100%}.progress:not(:last-child){margin-bottom:1.5rem}.progress::-webkit-progress-bar{background-color:#dbdbdb}.progress::-webkit-progress-value{background-color:#4a4a4a}.progress::-moz-progress-bar{background-color:#4a4a4a}.progress::-ms-fill{background-color:#4a4a4a;border:none}.progress.is-white::-webkit-progress-value{background-color:#fff}.progress.is-white::-moz-progress-bar{background-color:#fff}.progress.is-white::-ms-fill{background-color:#fff}.progress.is-black::-webkit-progress-value{background-color:#0a0a0a}.progress.is-black::-moz-progress-bar{background-color:#0a0a0a}.progress.is-black::-ms-fill{background-color:#0a0a0a}.progress.is-light::-webkit-progress-value{background-color:#f5f5f5}.progress.is-light::-moz-progress-bar{background-color:#f5f5f5}.progress.is-light::-ms-fill{background-color:#f5f5f5}.progress.is-dark::-webkit-progress-value{background-color:#363636}.progress.is-dark::-moz-progress-bar{background-color:#363636}.progress.is-dark::-ms-fill{background-color:#363636}.progress.is-primary::-webkit-progress-value{background-color:#00d1b2}.progress.is-primary::-moz-progress-bar{background-color:#00d1b2}.progress.is-primary::-ms-fill{background-color:#00d1b2}.progress.is-link::-webkit-progress-value{background-color:#3273dc}.progress.is-link::-moz-progress-bar{background-color:#3273dc}.progress.is-link::-ms-fill{background-color:#3273dc}.progress.is-info::-webkit-progress-value{background-color:#209cee}.progress.is-info::-moz-progress-bar{background-color:#209cee}.progress.is-info::-ms-fill{background-color:#209cee}.progress.is-success::-webkit-progress-value{background-color:#23d160}.progress.is-success::-moz-progress-bar{background-color:#23d160}.progress.is-success::-ms-fill{background-color:#23d160}.progress.is-warning::-webkit-progress-value{background-color:#ffdd57}.progress.is-warning::-moz-progress-bar{background-color:#ffdd57}.progress.is-warning::-ms-fill{background-color:#ffdd57}.progress.is-danger::-webkit-progress-value{background-color:#ff3860}.progress.is-danger::-moz-progress-bar{background-color:#ff3860}.progress.is-danger::-ms-fill{background-color:#ff3860}.progress.is-small{height:.75rem}.progress.is-medium{height:1.25rem}.progress.is-large{height:1.5rem}.table{background-color:#fff;color:#363636;margin-bottom:1.5rem}.table td,.table th{border:1px solid #dbdbdb;border-width:0 0 1px;padding:.5em .75em;vertical-align:top}.table td.is-white,.table th.is-white{background-color:#fff;border-color:#fff;color:#0a0a0a}.table td.is-black,.table th.is-black{background-color:#0a0a0a;border-color:#0a0a0a;color:#fff}.table td.is-light,.table th.is-light{background-color:#f5f5f5;border-color:#f5f5f5;color:#363636}.table td.is-dark,.table th.is-dark{background-color:#363636;border-color:#363636;color:#f5f5f5}.table td.is-primary,.table th.is-primary{background-color:#00d1b2;border-color:#00d1b2;color:#fff}.table td.is-link,.table th.is-link{background-color:#3273dc;border-color:#3273dc;color:#fff}.table td.is-info,.table th.is-info{background-color:#209cee;border-color:#209cee;color:#fff}.table td.is-success,.table th.is-success{background-color:#23d160;border-color:#23d160;color:#fff}.table td.is-warning,.table th.is-warning{background-color:#ffdd57;border-color:#ffdd57;color:rgba(0,0,0,.7)}.table td.is-danger,.table th.is-danger{background-color:#ff3860;border-color:#ff3860;color:#fff}.table td.is-narrow,.table th.is-narrow{white-space:nowrap;width:1%}.table td.is-selected,.table th.is-selected{background-color:#00d1b2;color:#fff}.table td.is-selected a,.table td.is-selected strong,.table th.is-selected a,.table th.is-selected strong{color:currentColor}.table th{color:#363636;text-align:left}.table tr.is-selected{background-color:#00d1b2;color:#fff}.table tr.is-selected a,.table tr.is-selected strong{color:currentColor}.table tr.is-selected td,.table tr.is-selected th{border-color:#fff;color:currentColor}.table thead td,.table thead th{border-width:0 0 2px;color:#363636}.table tfoot td,.table tfoot th{border-width:2px 0 0;color:#363636}.table tbody tr:last-child td,.table tbody tr:last-child th{border-bottom-width:0}.table.is-bordered td,.table.is-bordered th{border-width:1px}.table.is-bordered tr:last-child td,.table.is-bordered tr:last-child th{border-bottom-width:1px}.table.is-fullwidth{width:100%}.table.is-hoverable tbody tr:not(.is-selected):hover{background-color:#fafafa}.table.is-hoverable.is-striped tbody tr:not(.is-selected):hover{background-color:#f5f5f5}.table.is-narrow td,.table.is-narrow th{padding:.25em .5em}.table.is-striped tbody tr:not(.is-selected):nth-child(even){background-color:#fafafa}.tags{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start}.tags .tag{margin-bottom:.5rem}.tags .tag:not(:last-child){margin-right:.5rem}.tags:last-child{margin-bottom:-.5rem}.tags:not(:last-child){margin-bottom:1rem}.tags.has-addons .tag{margin-right:0}.tags.has-addons .tag:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.tags.has-addons .tag:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.tags.is-centered{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.tags.is-centered .tag{margin-right:.25rem;margin-left:.25rem}.tags.is-right{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end}.tags.is-right .tag:not(:first-child){margin-left:.5rem}.tags.is-right .tag:not(:last-child){margin-right:0}.tag:not(body){-webkit-box-align:center;-ms-flex-align:center;align-items:center;background-color:#f5f5f5;border-radius:3px;color:#4a4a4a;display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-flex;font-size:.75rem;height:2em;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;line-height:1.5;padding-left:.75em;padding-right:.75em;white-space:nowrap}.tag:not(body) .delete{margin-left:.25em;margin-right:-.375em}.tag:not(body).is-white{background-color:#fff;color:#0a0a0a}.tag:not(body).is-black{background-color:#0a0a0a;color:#fff}.tag:not(body).is-light{background-color:#f5f5f5;color:#363636}.tag:not(body).is-dark{background-color:#363636;color:#f5f5f5}.tag:not(body).is-primary{background-color:#00d1b2;color:#fff}.tag:not(body).is-link{background-color:#3273dc;color:#fff}.tag:not(body).is-info{background-color:#209cee;color:#fff}.tag:not(body).is-success{background-color:#23d160;color:#fff}.tag:not(body).is-warning{background-color:#ffdd57;color:rgba(0,0,0,.7)}.tag:not(body).is-danger{background-color:#ff3860;color:#fff}.tag:not(body).is-medium{font-size:1rem}.tag:not(body).is-large{font-size:1.25rem}.tag:not(body) .icon:first-child:not(:last-child){margin-left:-.375em;margin-right:.1875em}.tag:not(body) .icon:last-child:not(:first-child){margin-left:.1875em;margin-right:-.375em}.tag:not(body) .icon:first-child:last-child{margin-left:-.375em;margin-right:-.375em}.tag:not(body).is-delete{margin-left:1px;padding:0;position:relative;width:2em}.tag:not(body).is-delete:after,.tag:not(body).is-delete:before{background-color:currentColor;content:"";display:block;left:50%;position:absolute;top:50%;-webkit-transform:translateX(-50%) translateY(-50%) rotate(45deg);transform:translateX(-50%) translateY(-50%) rotate(45deg);-webkit-transform-origin:center center;transform-origin:center center}.tag:not(body).is-delete:before{height:1px;width:50%}.tag:not(body).is-delete:after{height:50%;width:1px}.tag:not(body).is-delete:focus,.tag:not(body).is-delete:hover{background-color:#e8e8e8}.tag:not(body).is-delete:active{background-color:#dbdbdb}.tag:not(body).is-rounded{border-radius:290486px}a.tag:hover{text-decoration:underline}.subtitle,.title{word-break:break-word}.subtitle:not(:last-child),.title:not(:last-child){margin-bottom:1.5rem}.subtitle em,.subtitle span,.title em,.title span{font-weight:inherit}.subtitle sub,.title sub{font-size:.75em}.subtitle sup,.title sup{font-size:.75em}.subtitle .tag,.title .tag{vertical-align:middle}.title{color:#363636;font-size:2rem;font-weight:600;line-height:1.125}.title strong{color:inherit;font-weight:inherit}.title+.highlight{margin-top:-.75rem}.title:not(.is-spaced)+.subtitle{margin-top:-1.5rem}.title.is-1{font-size:3rem}.title.is-2{font-size:2.5rem}.title.is-3{font-size:2rem}.title.is-4{font-size:1.5rem}.title.is-5{font-size:1.25rem}.title.is-6{font-size:1rem}.title.is-7{font-size:.75rem}.subtitle{color:#4a4a4a;font-size:1.25rem;font-weight:400;line-height:1.25}.subtitle strong{color:#363636;font-weight:600}.subtitle:not(.is-spaced)+.title{margin-top:-1.5rem}.subtitle.is-1{font-size:3rem}.subtitle.is-2{font-size:2.5rem}.subtitle.is-3{font-size:2rem}.subtitle.is-4{font-size:1.5rem}.subtitle.is-5{font-size:1.25rem}.subtitle.is-6{font-size:1rem}.subtitle.is-7{font-size:.75rem}.block:not(:last-child){margin-bottom:1.5rem}.delete{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-moz-appearance:none;-webkit-appearance:none;background-color:rgba(10,10,10,.2);border:none;border-radius:290486px;cursor:pointer;display:inline-block;-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0;font-size:0;height:20px;max-height:20px;max-width:20px;min-height:20px;min-width:20px;outline:0;position:relative;vertical-align:top;width:20px}.delete:after,.delete:before{background-color:#fff;content:"";display:block;left:50%;position:absolute;top:50%;-webkit-transform:translateX(-50%) translateY(-50%) rotate(45deg);transform:translateX(-50%) translateY(-50%) rotate(45deg);-webkit-transform-origin:center center;transform-origin:center center}.delete:before{height:2px;width:50%}.delete:after{height:50%;width:2px}.delete:focus,.delete:hover{background-color:rgba(10,10,10,.3)}.delete:active{background-color:rgba(10,10,10,.4)}.delete.is-small{height:16px;max-height:16px;max-width:16px;min-height:16px;min-width:16px;width:16px}.delete.is-medium{height:24px;max-height:24px;max-width:24px;min-height:24px;min-width:24px;width:24px}.delete.is-large{height:32px;max-height:32px;max-width:32px;min-height:32px;min-width:32px;width:32px}.heading{display:block;font-size:11px;letter-spacing:1px;margin-bottom:5px;text-transform:uppercase}.highlight{font-weight:400;max-width:100%;overflow:hidden;padding:0}.highlight:not(:last-child){margin-bottom:1.5rem}.highlight pre{overflow:auto;max-width:100%}.loader{-webkit-animation:spinAround .5s infinite linear;animation:spinAround .5s infinite linear;border:2px solid #dbdbdb;border-radius:290486px;border-right-color:transparent;border-top-color:transparent;content:"";display:block;height:1em;position:relative;width:1em}.number{-webkit-box-align:center;-ms-flex-align:center;align-items:center;background-color:#f5f5f5;border-radius:290486px;display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-flex;font-size:1.25rem;height:2em;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;margin-right:1.5rem;min-width:2.5em;padding:.25rem .5rem;text-align:center;vertical-align:top}.breadcrumb{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:1rem;overflow:hidden;overflow-x:auto;white-space:nowrap}.breadcrumb:not(:last-child){margin-bottom:1.5rem}.breadcrumb a{-webkit-box-align:center;-ms-flex-align:center;align-items:center;color:#3273dc;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;padding:.5em .75em}.breadcrumb a:hover{color:#363636}.breadcrumb li{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex}.breadcrumb li:first-child a{padding-left:0}.breadcrumb li.is-active a{color:#363636;cursor:default;pointer-events:none}.breadcrumb li+li::before{color:#4a4a4a;content:"\0002f"}.breadcrumb ol,.breadcrumb ul{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start}.breadcrumb .icon:first-child{margin-right:.5em}.breadcrumb .icon:last-child{margin-left:.5em}.breadcrumb.is-centered ol,.breadcrumb.is-centered ul{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.breadcrumb.is-right ol,.breadcrumb.is-right ul{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end}.breadcrumb.is-small{font-size:.75rem}.breadcrumb.is-medium{font-size:1.25rem}.breadcrumb.is-large{font-size:1.5rem}.breadcrumb.has-arrow-separator li+li::before{content:"\02192"}.breadcrumb.has-bullet-separator li+li::before{content:"\02022"}.breadcrumb.has-dot-separator li+li::before{content:"\000b7"}.breadcrumb.has-succeeds-separator li+li::before{content:"\0227B"}.card{background-color:#fff;-webkit-box-shadow:0 2px 3px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);box-shadow:0 2px 3px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);color:#4a4a4a;max-width:100%;position:relative}.card-header{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-shadow:0 1px 2px rgba(10,10,10,.1);box-shadow:0 1px 2px rgba(10,10,10,.1);display:-webkit-box;display:-ms-flexbox;display:flex}.card-header-title{-webkit-box-align:center;-ms-flex-align:center;align-items:center;color:#363636;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;font-weight:700;padding:.75rem}.card-header-title.is-centered{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.card-header-icon{-webkit-box-align:center;-ms-flex-align:center;align-items:center;cursor:pointer;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;padding:.75rem}.card-image{display:block;position:relative}.card-content{padding:1.5rem}.card-footer{border-top:1px solid #dbdbdb;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex}.card-footer-item{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;padding:.75rem}.card-footer-item:not(:last-child){border-right:1px solid #dbdbdb}.card .media:not(:last-child){margin-bottom:.75rem}.dropdown{display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-flex;position:relative;vertical-align:top}.dropdown.is-active .dropdown-menu,.dropdown.is-hoverable:hover .dropdown-menu{display:block}.dropdown.is-right .dropdown-menu{left:auto;right:0}.dropdown.is-up .dropdown-menu{bottom:100%;padding-bottom:4px;padding-top:unset;top:auto}.dropdown-menu{display:none;left:0;min-width:12rem;padding-top:4px;position:absolute;top:100%;z-index:20}.dropdown-content{background-color:#fff;border-radius:3px;-webkit-box-shadow:0 2px 3px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);box-shadow:0 2px 3px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);padding-bottom:.5rem;padding-top:.5rem}.dropdown-item{color:#4a4a4a;display:block;font-size:.875rem;line-height:1.5;padding:.375rem 1rem;position:relative}a.dropdown-item{padding-right:3rem;white-space:nowrap}a.dropdown-item:hover{background-color:#f5f5f5;color:#0a0a0a}a.dropdown-item.is-active{background-color:#3273dc;color:#fff}.dropdown-divider{background-color:#dbdbdb;border:none;display:block;height:1px;margin:.5rem 0}.level{-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-ms-flex-pack:justify;justify-content:space-between}.level:not(:last-child){margin-bottom:1.5rem}.level code{border-radius:3px}.level img{display:inline-block;vertical-align:top}.level.is-mobile{display:-webkit-box;display:-ms-flexbox;display:flex}.level.is-mobile .level-left,.level.is-mobile .level-right{display:-webkit-box;display:-ms-flexbox;display:flex}.level.is-mobile .level-left+.level-right{margin-top:0}.level.is-mobile .level-item{margin-right:.75rem}.level.is-mobile .level-item:not(:last-child){margin-bottom:0}.level.is-mobile .level-item:not(.is-narrow){-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1}@media screen and (min-width:769px),print{.level{display:-webkit-box;display:-ms-flexbox;display:flex}.level>.level-item:not(.is-narrow){-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1}}.level-item{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-preferred-size:auto;flex-basis:auto;-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.level-item .subtitle,.level-item .title{margin-bottom:0}@media screen and (max-width:768px){.level-item:not(:last-child){margin-bottom:.75rem}}.level-left,.level-right{-ms-flex-preferred-size:auto;flex-basis:auto;-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0}.level-left .level-item.is-flexible,.level-right .level-item.is-flexible{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1}@media screen and (min-width:769px),print{.level-left .level-item:not(:last-child),.level-right .level-item:not(:last-child){margin-right:.75rem}}.level-left{-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start}@media screen and (max-width:768px){.level-left+.level-right{margin-top:1.5rem}}@media screen and (min-width:769px),print{.level-left{display:-webkit-box;display:-ms-flexbox;display:flex}}.level-right{-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end}@media screen and (min-width:769px),print{.level-right{display:-webkit-box;display:-ms-flexbox;display:flex}}.media{-webkit-box-align:start;-ms-flex-align:start;align-items:flex-start;display:-webkit-box;display:-ms-flexbox;display:flex;text-align:left}.media .content:not(:last-child){margin-bottom:.75rem}.media .media{border-top:1px solid rgba(219,219,219,.5);display:-webkit-box;display:-ms-flexbox;display:flex;padding-top:.75rem}.media .media .content:not(:last-child),.media .media .control:not(:last-child){margin-bottom:.5rem}.media .media .media{padding-top:.5rem}.media .media .media+.media{margin-top:.5rem}.media+.media{border-top:1px solid rgba(219,219,219,.5);margin-top:1rem;padding-top:1rem}.media.is-large+.media{margin-top:1.5rem;padding-top:1.5rem}.media-left,.media-right{-ms-flex-preferred-size:auto;flex-basis:auto;-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0}.media-left{margin-right:1rem}.media-right{margin-left:1rem}.media-content{-ms-flex-preferred-size:auto;flex-basis:auto;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;overflow:auto;text-align:left}.menu{font-size:1rem}.menu.is-small{font-size:.75rem}.menu.is-medium{font-size:1.25rem}.menu.is-large{font-size:1.5rem}.menu-list{line-height:1.25}.menu-list a{border-radius:2px;color:#4a4a4a;display:block;padding:.5em .75em}.menu-list a:hover{background-color:#f5f5f5;color:#363636}.menu-list a.is-active{background-color:#3273dc;color:#fff}.menu-list li ul{border-left:1px solid #dbdbdb;margin:.75em;padding-left:.75em}.menu-label{color:#7a7a7a;font-size:.75em;letter-spacing:.1em;text-transform:uppercase}.menu-label:not(:first-child){margin-top:1em}.menu-label:not(:last-child){margin-bottom:1em}.message{background-color:#f5f5f5;border-radius:3px;font-size:1rem}.message:not(:last-child){margin-bottom:1.5rem}.message strong{color:currentColor}.message a:not(.button):not(.tag){color:currentColor;text-decoration:underline}.message.is-small{font-size:.75rem}.message.is-medium{font-size:1.25rem}.message.is-large{font-size:1.5rem}.message.is-white{background-color:#fff}.message.is-white .message-header{background-color:#fff;color:#0a0a0a}.message.is-white .message-body{border-color:#fff;color:#4d4d4d}.message.is-black{background-color:#fafafa}.message.is-black .message-header{background-color:#0a0a0a;color:#fff}.message.is-black .message-body{border-color:#0a0a0a;color:#090909}.message.is-light{background-color:#fafafa}.message.is-light .message-header{background-color:#f5f5f5;color:#363636}.message.is-light .message-body{border-color:#f5f5f5;color:#505050}.message.is-dark{background-color:#fafafa}.message.is-dark .message-header{background-color:#363636;color:#f5f5f5}.message.is-dark .message-body{border-color:#363636;color:#2a2a2a}.message.is-primary{background-color:#f5fffd}.message.is-primary .message-header{background-color:#00d1b2;color:#fff}.message.is-primary .message-body{border-color:#00d1b2;color:#021310}.message.is-link{background-color:#f6f9fe}.message.is-link .message-header{background-color:#3273dc;color:#fff}.message.is-link .message-body{border-color:#3273dc;color:#22509a}.message.is-info{background-color:#f6fbfe}.message.is-info .message-header{background-color:#209cee;color:#fff}.message.is-info .message-body{border-color:#209cee;color:#12537e}.message.is-success{background-color:#f6fef9}.message.is-success .message-header{background-color:#23d160;color:#fff}.message.is-success .message-body{border-color:#23d160;color:#0e301a}.message.is-warning{background-color:#fffdf5}.message.is-warning .message-header{background-color:#ffdd57;color:rgba(0,0,0,.7)}.message.is-warning .message-body{border-color:#ffdd57;color:#3b3108}.message.is-danger{background-color:#fff5f7}.message.is-danger .message-header{background-color:#ff3860;color:#fff}.message.is-danger .message-body{border-color:#ff3860;color:#cd0930}.message-header{-webkit-box-align:center;-ms-flex-align:center;align-items:center;background-color:#4a4a4a;border-radius:3px 3px 0 0;color:#fff;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-ms-flex-pack:justify;justify-content:space-between;line-height:1.25;padding:.5em .75em;position:relative}.message-header .delete{-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0;margin-left:.75em}.message-header+.message-body{border-top-left-radius:0;border-top-right-radius:0;border-top:none}.message-body{border:1px solid #dbdbdb;border-radius:3px;color:#4a4a4a;padding:1em 1.25em}.message-body code,.message-body pre{background-color:#fff}.message-body pre code{background-color:transparent}.modal{bottom:0;left:0;position:absolute;right:0;top:0;-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:none;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;overflow:hidden;position:fixed;z-index:40}.modal.is-active{display:-webkit-box;display:-ms-flexbox;display:flex}.modal-background{bottom:0;left:0;position:absolute;right:0;top:0;background-color:rgba(10,10,10,.86)}.modal-card,.modal-content{margin:0 20px;max-height:calc(100vh - 160px);overflow:auto;position:relative;width:100%}@media screen and (min-width:769px),print{.modal-card,.modal-content{margin:0 auto;max-height:calc(100vh - 40px);width:640px}}.modal-close{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-moz-appearance:none;-webkit-appearance:none;background-color:rgba(10,10,10,.2);border:none;border-radius:290486px;cursor:pointer;display:inline-block;-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0;font-size:0;height:20px;max-height:20px;max-width:20px;min-height:20px;min-width:20px;outline:0;position:relative;vertical-align:top;width:20px;background:0 0;height:40px;position:fixed;right:20px;top:20px;width:40px}.modal-close:after,.modal-close:before{background-color:#fff;content:"";display:block;left:50%;position:absolute;top:50%;-webkit-transform:translateX(-50%) translateY(-50%) rotate(45deg);transform:translateX(-50%) translateY(-50%) rotate(45deg);-webkit-transform-origin:center center;transform-origin:center center}.modal-close:before{height:2px;width:50%}.modal-close:after{height:50%;width:2px}.modal-close:focus,.modal-close:hover{background-color:rgba(10,10,10,.3)}.modal-close:active{background-color:rgba(10,10,10,.4)}.modal-close.is-small{height:16px;max-height:16px;max-width:16px;min-height:16px;min-width:16px;width:16px}.modal-close.is-medium{height:24px;max-height:24px;max-width:24px;min-height:24px;min-width:24px;width:24px}.modal-close.is-large{height:32px;max-height:32px;max-width:32px;min-height:32px;min-width:32px;width:32px}.modal-card{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;max-height:calc(100vh - 40px);overflow:hidden}.modal-card-foot,.modal-card-head{-webkit-box-align:center;-ms-flex-align:center;align-items:center;background-color:#f5f5f5;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-negative:0;flex-shrink:0;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start;padding:20px;position:relative}.modal-card-head{border-bottom:1px solid #dbdbdb;border-top-left-radius:5px;border-top-right-radius:5px}.modal-card-title{color:#363636;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;font-size:1.5rem;line-height:1}.modal-card-foot{border-bottom-left-radius:5px;border-bottom-right-radius:5px;border-top:1px solid #dbdbdb}.modal-card-foot .button:not(:last-child){margin-right:10px}.modal-card-body{-webkit-overflow-scrolling:touch;background-color:#fff;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;overflow:auto;padding:20px}.navbar{background-color:#fff;min-height:3.25rem;position:relative}.navbar.is-white{background-color:#fff;color:#0a0a0a}.navbar.is-white .navbar-brand .navbar-link,.navbar.is-white .navbar-brand>.navbar-item{color:#0a0a0a}.navbar.is-white .navbar-brand .navbar-link.is-active,.navbar.is-white .navbar-brand .navbar-link:hover,.navbar.is-white .navbar-brand>a.navbar-item.is-active,.navbar.is-white .navbar-brand>a.navbar-item:hover{background-color:#f2f2f2;color:#0a0a0a}.navbar.is-white .navbar-brand .navbar-link::after{border-color:#0a0a0a}@media screen and (min-width:1024px){.navbar.is-white .navbar-end .navbar-link,.navbar.is-white .navbar-end>.navbar-item,.navbar.is-white .navbar-start .navbar-link,.navbar.is-white .navbar-start>.navbar-item{color:#0a0a0a}.navbar.is-white .navbar-end .navbar-link.is-active,.navbar.is-white .navbar-end .navbar-link:hover,.navbar.is-white .navbar-end>a.navbar-item.is-active,.navbar.is-white .navbar-end>a.navbar-item:hover,.navbar.is-white .navbar-start .navbar-link.is-active,.navbar.is-white .navbar-start .navbar-link:hover,.navbar.is-white .navbar-start>a.navbar-item.is-active,.navbar.is-white .navbar-start>a.navbar-item:hover{background-color:#f2f2f2;color:#0a0a0a}.navbar.is-white .navbar-end .navbar-link::after,.navbar.is-white .navbar-start .navbar-link::after{border-color:#0a0a0a}.navbar.is-white .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-white .navbar-item.has-dropdown:hover .navbar-link{background-color:#f2f2f2;color:#0a0a0a}.navbar.is-white .navbar-dropdown a.navbar-item.is-active{background-color:#fff;color:#0a0a0a}}.navbar.is-black{background-color:#0a0a0a;color:#fff}.navbar.is-black .navbar-brand .navbar-link,.navbar.is-black .navbar-brand>.navbar-item{color:#fff}.navbar.is-black .navbar-brand .navbar-link.is-active,.navbar.is-black .navbar-brand .navbar-link:hover,.navbar.is-black .navbar-brand>a.navbar-item.is-active,.navbar.is-black .navbar-brand>a.navbar-item:hover{background-color:#000;color:#fff}.navbar.is-black .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-black .navbar-end .navbar-link,.navbar.is-black .navbar-end>.navbar-item,.navbar.is-black .navbar-start .navbar-link,.navbar.is-black .navbar-start>.navbar-item{color:#fff}.navbar.is-black .navbar-end .navbar-link.is-active,.navbar.is-black .navbar-end .navbar-link:hover,.navbar.is-black .navbar-end>a.navbar-item.is-active,.navbar.is-black .navbar-end>a.navbar-item:hover,.navbar.is-black .navbar-start .navbar-link.is-active,.navbar.is-black .navbar-start .navbar-link:hover,.navbar.is-black .navbar-start>a.navbar-item.is-active,.navbar.is-black .navbar-start>a.navbar-item:hover{background-color:#000;color:#fff}.navbar.is-black .navbar-end .navbar-link::after,.navbar.is-black .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-black .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-black .navbar-item.has-dropdown:hover .navbar-link{background-color:#000;color:#fff}.navbar.is-black .navbar-dropdown a.navbar-item.is-active{background-color:#0a0a0a;color:#fff}}.navbar.is-light{background-color:#f5f5f5;color:#363636}.navbar.is-light .navbar-brand .navbar-link,.navbar.is-light .navbar-brand>.navbar-item{color:#363636}.navbar.is-light .navbar-brand .navbar-link.is-active,.navbar.is-light .navbar-brand .navbar-link:hover,.navbar.is-light .navbar-brand>a.navbar-item.is-active,.navbar.is-light .navbar-brand>a.navbar-item:hover{background-color:#e8e8e8;color:#363636}.navbar.is-light .navbar-brand .navbar-link::after{border-color:#363636}@media screen and (min-width:1024px){.navbar.is-light .navbar-end .navbar-link,.navbar.is-light .navbar-end>.navbar-item,.navbar.is-light .navbar-start .navbar-link,.navbar.is-light .navbar-start>.navbar-item{color:#363636}.navbar.is-light .navbar-end .navbar-link.is-active,.navbar.is-light .navbar-end .navbar-link:hover,.navbar.is-light .navbar-end>a.navbar-item.is-active,.navbar.is-light .navbar-end>a.navbar-item:hover,.navbar.is-light .navbar-start .navbar-link.is-active,.navbar.is-light .navbar-start .navbar-link:hover,.navbar.is-light .navbar-start>a.navbar-item.is-active,.navbar.is-light .navbar-start>a.navbar-item:hover{background-color:#e8e8e8;color:#363636}.navbar.is-light .navbar-end .navbar-link::after,.navbar.is-light .navbar-start .navbar-link::after{border-color:#363636}.navbar.is-light .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-light .navbar-item.has-dropdown:hover .navbar-link{background-color:#e8e8e8;color:#363636}.navbar.is-light .navbar-dropdown a.navbar-item.is-active{background-color:#f5f5f5;color:#363636}}.navbar.is-dark{background-color:#363636;color:#f5f5f5}.navbar.is-dark .navbar-brand .navbar-link,.navbar.is-dark .navbar-brand>.navbar-item{color:#f5f5f5}.navbar.is-dark .navbar-brand .navbar-link.is-active,.navbar.is-dark .navbar-brand .navbar-link:hover,.navbar.is-dark .navbar-brand>a.navbar-item.is-active,.navbar.is-dark .navbar-brand>a.navbar-item:hover{background-color:#292929;color:#f5f5f5}.navbar.is-dark .navbar-brand .navbar-link::after{border-color:#f5f5f5}@media screen and (min-width:1024px){.navbar.is-dark .navbar-end .navbar-link,.navbar.is-dark .navbar-end>.navbar-item,.navbar.is-dark .navbar-start .navbar-link,.navbar.is-dark .navbar-start>.navbar-item{color:#f5f5f5}.navbar.is-dark .navbar-end .navbar-link.is-active,.navbar.is-dark .navbar-end .navbar-link:hover,.navbar.is-dark .navbar-end>a.navbar-item.is-active,.navbar.is-dark .navbar-end>a.navbar-item:hover,.navbar.is-dark .navbar-start .navbar-link.is-active,.navbar.is-dark .navbar-start .navbar-link:hover,.navbar.is-dark .navbar-start>a.navbar-item.is-active,.navbar.is-dark .navbar-start>a.navbar-item:hover{background-color:#292929;color:#f5f5f5}.navbar.is-dark .navbar-end .navbar-link::after,.navbar.is-dark .navbar-start .navbar-link::after{border-color:#f5f5f5}.navbar.is-dark .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-dark .navbar-item.has-dropdown:hover .navbar-link{background-color:#292929;color:#f5f5f5}.navbar.is-dark .navbar-dropdown a.navbar-item.is-active{background-color:#363636;color:#f5f5f5}}.navbar.is-primary{background-color:#00d1b2;color:#fff}.navbar.is-primary .navbar-brand .navbar-link,.navbar.is-primary .navbar-brand>.navbar-item{color:#fff}.navbar.is-primary .navbar-brand .navbar-link.is-active,.navbar.is-primary .navbar-brand .navbar-link:hover,.navbar.is-primary .navbar-brand>a.navbar-item.is-active,.navbar.is-primary .navbar-brand>a.navbar-item:hover{background-color:#00b89c;color:#fff}.navbar.is-primary .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-primary .navbar-end .navbar-link,.navbar.is-primary .navbar-end>.navbar-item,.navbar.is-primary .navbar-start .navbar-link,.navbar.is-primary .navbar-start>.navbar-item{color:#fff}.navbar.is-primary .navbar-end .navbar-link.is-active,.navbar.is-primary .navbar-end .navbar-link:hover,.navbar.is-primary .navbar-end>a.navbar-item.is-active,.navbar.is-primary .navbar-end>a.navbar-item:hover,.navbar.is-primary .navbar-start .navbar-link.is-active,.navbar.is-primary .navbar-start .navbar-link:hover,.navbar.is-primary .navbar-start>a.navbar-item.is-active,.navbar.is-primary .navbar-start>a.navbar-item:hover{background-color:#00b89c;color:#fff}.navbar.is-primary .navbar-end .navbar-link::after,.navbar.is-primary .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-primary .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-primary .navbar-item.has-dropdown:hover .navbar-link{background-color:#00b89c;color:#fff}.navbar.is-primary .navbar-dropdown a.navbar-item.is-active{background-color:#00d1b2;color:#fff}}.navbar.is-link{background-color:#3273dc;color:#fff}.navbar.is-link .navbar-brand .navbar-link,.navbar.is-link .navbar-brand>.navbar-item{color:#fff}.navbar.is-link .navbar-brand .navbar-link.is-active,.navbar.is-link .navbar-brand .navbar-link:hover,.navbar.is-link .navbar-brand>a.navbar-item.is-active,.navbar.is-link .navbar-brand>a.navbar-item:hover{background-color:#2366d1;color:#fff}.navbar.is-link .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-link .navbar-end .navbar-link,.navbar.is-link .navbar-end>.navbar-item,.navbar.is-link .navbar-start .navbar-link,.navbar.is-link .navbar-start>.navbar-item{color:#fff}.navbar.is-link .navbar-end .navbar-link.is-active,.navbar.is-link .navbar-end .navbar-link:hover,.navbar.is-link .navbar-end>a.navbar-item.is-active,.navbar.is-link .navbar-end>a.navbar-item:hover,.navbar.is-link .navbar-start .navbar-link.is-active,.navbar.is-link .navbar-start .navbar-link:hover,.navbar.is-link .navbar-start>a.navbar-item.is-active,.navbar.is-link .navbar-start>a.navbar-item:hover{background-color:#2366d1;color:#fff}.navbar.is-link .navbar-end .navbar-link::after,.navbar.is-link .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-link .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-link .navbar-item.has-dropdown:hover .navbar-link{background-color:#2366d1;color:#fff}.navbar.is-link .navbar-dropdown a.navbar-item.is-active{background-color:#3273dc;color:#fff}}.navbar.is-info{background-color:#209cee;color:#fff}.navbar.is-info .navbar-brand .navbar-link,.navbar.is-info .navbar-brand>.navbar-item{color:#fff}.navbar.is-info .navbar-brand .navbar-link.is-active,.navbar.is-info .navbar-brand .navbar-link:hover,.navbar.is-info .navbar-brand>a.navbar-item.is-active,.navbar.is-info .navbar-brand>a.navbar-item:hover{background-color:#118fe4;color:#fff}.navbar.is-info .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-info .navbar-end .navbar-link,.navbar.is-info .navbar-end>.navbar-item,.navbar.is-info .navbar-start .navbar-link,.navbar.is-info .navbar-start>.navbar-item{color:#fff}.navbar.is-info .navbar-end .navbar-link.is-active,.navbar.is-info .navbar-end .navbar-link:hover,.navbar.is-info .navbar-end>a.navbar-item.is-active,.navbar.is-info .navbar-end>a.navbar-item:hover,.navbar.is-info .navbar-start .navbar-link.is-active,.navbar.is-info .navbar-start .navbar-link:hover,.navbar.is-info .navbar-start>a.navbar-item.is-active,.navbar.is-info .navbar-start>a.navbar-item:hover{background-color:#118fe4;color:#fff}.navbar.is-info .navbar-end .navbar-link::after,.navbar.is-info .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-info .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-info .navbar-item.has-dropdown:hover .navbar-link{background-color:#118fe4;color:#fff}.navbar.is-info .navbar-dropdown a.navbar-item.is-active{background-color:#209cee;color:#fff}}.navbar.is-success{background-color:#23d160;color:#fff}.navbar.is-success .navbar-brand .navbar-link,.navbar.is-success .navbar-brand>.navbar-item{color:#fff}.navbar.is-success .navbar-brand .navbar-link.is-active,.navbar.is-success .navbar-brand .navbar-link:hover,.navbar.is-success .navbar-brand>a.navbar-item.is-active,.navbar.is-success .navbar-brand>a.navbar-item:hover{background-color:#20bc56;color:#fff}.navbar.is-success .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-success .navbar-end .navbar-link,.navbar.is-success .navbar-end>.navbar-item,.navbar.is-success .navbar-start .navbar-link,.navbar.is-success .navbar-start>.navbar-item{color:#fff}.navbar.is-success .navbar-end .navbar-link.is-active,.navbar.is-success .navbar-end .navbar-link:hover,.navbar.is-success .navbar-end>a.navbar-item.is-active,.navbar.is-success .navbar-end>a.navbar-item:hover,.navbar.is-success .navbar-start .navbar-link.is-active,.navbar.is-success .navbar-start .navbar-link:hover,.navbar.is-success .navbar-start>a.navbar-item.is-active,.navbar.is-success .navbar-start>a.navbar-item:hover{background-color:#20bc56;color:#fff}.navbar.is-success .navbar-end .navbar-link::after,.navbar.is-success .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-success .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-success .navbar-item.has-dropdown:hover .navbar-link{background-color:#20bc56;color:#fff}.navbar.is-success .navbar-dropdown a.navbar-item.is-active{background-color:#23d160;color:#fff}}.navbar.is-warning{background-color:#ffdd57;color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-brand .navbar-link,.navbar.is-warning .navbar-brand>.navbar-item{color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-brand .navbar-link.is-active,.navbar.is-warning .navbar-brand .navbar-link:hover,.navbar.is-warning .navbar-brand>a.navbar-item.is-active,.navbar.is-warning .navbar-brand>a.navbar-item:hover{background-color:#ffd83d;color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-brand .navbar-link::after{border-color:rgba(0,0,0,.7)}@media screen and (min-width:1024px){.navbar.is-warning .navbar-end .navbar-link,.navbar.is-warning .navbar-end>.navbar-item,.navbar.is-warning .navbar-start .navbar-link,.navbar.is-warning .navbar-start>.navbar-item{color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-end .navbar-link.is-active,.navbar.is-warning .navbar-end .navbar-link:hover,.navbar.is-warning .navbar-end>a.navbar-item.is-active,.navbar.is-warning .navbar-end>a.navbar-item:hover,.navbar.is-warning .navbar-start .navbar-link.is-active,.navbar.is-warning .navbar-start .navbar-link:hover,.navbar.is-warning .navbar-start>a.navbar-item.is-active,.navbar.is-warning .navbar-start>a.navbar-item:hover{background-color:#ffd83d;color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-end .navbar-link::after,.navbar.is-warning .navbar-start .navbar-link::after{border-color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-warning .navbar-item.has-dropdown:hover .navbar-link{background-color:#ffd83d;color:rgba(0,0,0,.7)}.navbar.is-warning .navbar-dropdown a.navbar-item.is-active{background-color:#ffdd57;color:rgba(0,0,0,.7)}}.navbar.is-danger{background-color:#ff3860;color:#fff}.navbar.is-danger .navbar-brand .navbar-link,.navbar.is-danger .navbar-brand>.navbar-item{color:#fff}.navbar.is-danger .navbar-brand .navbar-link.is-active,.navbar.is-danger .navbar-brand .navbar-link:hover,.navbar.is-danger .navbar-brand>a.navbar-item.is-active,.navbar.is-danger .navbar-brand>a.navbar-item:hover{background-color:#ff1f4b;color:#fff}.navbar.is-danger .navbar-brand .navbar-link::after{border-color:#fff}@media screen and (min-width:1024px){.navbar.is-danger .navbar-end .navbar-link,.navbar.is-danger .navbar-end>.navbar-item,.navbar.is-danger .navbar-start .navbar-link,.navbar.is-danger .navbar-start>.navbar-item{color:#fff}.navbar.is-danger .navbar-end .navbar-link.is-active,.navbar.is-danger .navbar-end .navbar-link:hover,.navbar.is-danger .navbar-end>a.navbar-item.is-active,.navbar.is-danger .navbar-end>a.navbar-item:hover,.navbar.is-danger .navbar-start .navbar-link.is-active,.navbar.is-danger .navbar-start .navbar-link:hover,.navbar.is-danger .navbar-start>a.navbar-item.is-active,.navbar.is-danger .navbar-start>a.navbar-item:hover{background-color:#ff1f4b;color:#fff}.navbar.is-danger .navbar-end .navbar-link::after,.navbar.is-danger .navbar-start .navbar-link::after{border-color:#fff}.navbar.is-danger .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-danger .navbar-item.has-dropdown:hover .navbar-link{background-color:#ff1f4b;color:#fff}.navbar.is-danger .navbar-dropdown a.navbar-item.is-active{background-color:#ff3860;color:#fff}}.navbar>.container{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex;min-height:3.25rem;width:100%}.navbar.has-shadow{-webkit-box-shadow:0 2px 3px rgba(10,10,10,.1);box-shadow:0 2px 3px rgba(10,10,10,.1)}.navbar.is-fixed-bottom,.navbar.is-fixed-top{left:0;position:fixed;right:0;z-index:30}.navbar.is-fixed-bottom{bottom:0}.navbar.is-fixed-bottom.has-shadow{-webkit-box-shadow:0 -2px 3px rgba(10,10,10,.1);box-shadow:0 -2px 3px rgba(10,10,10,.1)}.navbar.is-fixed-top{top:0}html.has-navbar-fixed-top{padding-top:3.25rem}html.has-navbar-fixed-bottom{padding-bottom:3.25rem}.navbar-brand,.navbar-tabs{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-negative:0;flex-shrink:0;min-height:3.25rem}.navbar-tabs{-webkit-overflow-scrolling:touch;max-width:100vw;overflow-x:auto;overflow-y:hidden}.navbar-burger{cursor:pointer;display:block;height:3.25rem;position:relative;width:3.25rem;margin-left:auto}.navbar-burger span{background-color:currentColor;display:block;height:1px;left:calc(50% - 8px);position:absolute;-webkit-transform-origin:center;transform-origin:center;-webkit-transition-duration:86ms;transition-duration:86ms;-webkit-transition-property:background-color,opacity,-webkit-transform;transition-property:background-color,opacity,-webkit-transform;transition-property:background-color,opacity,transform;transition-property:background-color,opacity,transform,-webkit-transform;-webkit-transition-timing-function:ease-out;transition-timing-function:ease-out;width:16px}.navbar-burger span:nth-child(1){top:calc(50% - 6px)}.navbar-burger span:nth-child(2){top:calc(50% - 1px)}.navbar-burger span:nth-child(3){top:calc(50% + 4px)}.navbar-burger:hover{background-color:rgba(0,0,0,.05)}.navbar-burger.is-active span:nth-child(1){-webkit-transform:translateY(5px) rotate(45deg);transform:translateY(5px) rotate(45deg)}.navbar-burger.is-active span:nth-child(2){opacity:0}.navbar-burger.is-active span:nth-child(3){-webkit-transform:translateY(-5px) rotate(-45deg);transform:translateY(-5px) rotate(-45deg)}.navbar-menu{display:none}.navbar-item,.navbar-link{color:#4a4a4a;display:block;line-height:1.5;padding:.5rem 1rem;position:relative}a.navbar-item.is-active,a.navbar-item:hover,a.navbar-link.is-active,a.navbar-link:hover{background-color:#f5f5f5;color:#3273dc}.navbar-item{-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0}.navbar-item img{max-height:1.75rem}.navbar-item.has-dropdown{padding:0}.navbar-item.is-expanded{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}.navbar-item.is-tab{border-bottom:1px solid transparent;min-height:3.25rem;padding-bottom:calc(.5rem - 1px)}.navbar-item.is-tab:hover{background-color:transparent;border-bottom-color:#3273dc}.navbar-item.is-tab.is-active{background-color:transparent;border-bottom-color:#3273dc;border-bottom-style:solid;border-bottom-width:3px;color:#3273dc;padding-bottom:calc(.5rem - 3px)}.navbar-content{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}.navbar-link{padding-right:2.5em}.navbar-dropdown{font-size:.875rem;padding-bottom:.5rem;padding-top:.5rem}.navbar-dropdown .navbar-item{padding-left:1.5rem;padding-right:1.5rem}.navbar-divider{background-color:#dbdbdb;border:none;display:none;height:1px;margin:.5rem 0}@media screen and (max-width:1023px){.navbar>.container{display:block}.navbar-brand .navbar-item,.navbar-tabs .navbar-item{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex}.navbar-menu{background-color:#fff;-webkit-box-shadow:0 8px 16px rgba(10,10,10,.1);box-shadow:0 8px 16px rgba(10,10,10,.1);padding:.5rem 0}.navbar-menu.is-active{display:block}.navbar.is-fixed-bottom-touch,.navbar.is-fixed-top-touch{left:0;position:fixed;right:0;z-index:30}.navbar.is-fixed-bottom-touch{bottom:0}.navbar.is-fixed-bottom-touch.has-shadow{-webkit-box-shadow:0 -2px 3px rgba(10,10,10,.1);box-shadow:0 -2px 3px rgba(10,10,10,.1)}.navbar.is-fixed-top-touch{top:0}.navbar.is-fixed-top .navbar-menu,.navbar.is-fixed-top-touch .navbar-menu{-webkit-overflow-scrolling:touch;max-height:calc(100vh - 3.25rem);overflow:auto}html.has-navbar-fixed-top-touch{padding-top:3.25rem}html.has-navbar-fixed-bottom-touch{padding-bottom:3.25rem}}@media screen and (min-width:1024px){.navbar,.navbar-end,.navbar-menu,.navbar-start{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex}.navbar{min-height:3.25rem}.navbar.is-transparent a.navbar-item.is-active,.navbar.is-transparent a.navbar-item:hover,.navbar.is-transparent a.navbar-link.is-active,.navbar.is-transparent a.navbar-link:hover{background-color:transparent!important}.navbar.is-transparent .navbar-item.has-dropdown.is-active .navbar-link,.navbar.is-transparent .navbar-item.has-dropdown.is-hoverable:hover .navbar-link{background-color:transparent!important}.navbar.is-transparent .navbar-dropdown a.navbar-item:hover{background-color:#f5f5f5;color:#0a0a0a}.navbar.is-transparent .navbar-dropdown a.navbar-item.is-active{background-color:#f5f5f5;color:#3273dc}.navbar-burger{display:none}.navbar-item,.navbar-link{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex}.navbar-item.has-dropdown{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch}.navbar-item.has-dropdown-up .navbar-link::after{-webkit-transform:rotate(135deg) translate(.25em,-.25em);transform:rotate(135deg) translate(.25em,-.25em)}.navbar-item.has-dropdown-up .navbar-dropdown{border-bottom:1px solid #dbdbdb;border-radius:5px 5px 0 0;border-top:none;bottom:100%;-webkit-box-shadow:0 -8px 8px rgba(10,10,10,.1);box-shadow:0 -8px 8px rgba(10,10,10,.1);top:auto}.navbar-item.is-active .navbar-dropdown,.navbar-item.is-hoverable:hover .navbar-dropdown{display:block}.navbar-item.is-active .navbar-dropdown.is-boxed,.navbar-item.is-hoverable:hover .navbar-dropdown.is-boxed{opacity:1;pointer-events:auto;-webkit-transform:translateY(0);transform:translateY(0)}.navbar-link::after{border:1px solid #3273dc;border-right:0;border-top:0;content:" ";display:block;height:.5em;pointer-events:none;position:absolute;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:center;transform-origin:center;width:.5em;margin-top:-.375em;right:1.125em;top:50%}.navbar-menu{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0}.navbar-start{-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start;margin-right:auto}.navbar-end{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end;margin-left:auto}.navbar-dropdown{background-color:#fff;border-bottom-left-radius:5px;border-bottom-right-radius:5px;border-top:1px solid #dbdbdb;-webkit-box-shadow:0 8px 8px rgba(10,10,10,.1);box-shadow:0 8px 8px rgba(10,10,10,.1);display:none;font-size:.875rem;left:0;min-width:100%;position:absolute;top:100%;z-index:20}.navbar-dropdown .navbar-item{padding:.375rem 1rem;white-space:nowrap}.navbar-dropdown a.navbar-item{padding-right:3rem}.navbar-dropdown a.navbar-item:hover{background-color:#f5f5f5;color:#0a0a0a}.navbar-dropdown a.navbar-item.is-active{background-color:#f5f5f5;color:#3273dc}.navbar-dropdown.is-boxed{border-radius:5px;border-top:none;-webkit-box-shadow:0 8px 8px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);box-shadow:0 8px 8px rgba(10,10,10,.1),0 0 0 1px rgba(10,10,10,.1);display:block;opacity:0;pointer-events:none;top:calc(100% + (-4px));-webkit-transform:translateY(-5px);transform:translateY(-5px);-webkit-transition-duration:86ms;transition-duration:86ms;-webkit-transition-property:opacity,-webkit-transform;transition-property:opacity,-webkit-transform;transition-property:opacity,transform;transition-property:opacity,transform,-webkit-transform}.navbar-dropdown.is-right{left:auto;right:0}.navbar-divider{display:block}.container>.navbar .navbar-brand,.navbar>.container .navbar-brand{margin-left:-1rem}.container>.navbar .navbar-menu,.navbar>.container .navbar-menu{margin-right:-1rem}.navbar.is-fixed-bottom-desktop,.navbar.is-fixed-top-desktop{left:0;position:fixed;right:0;z-index:30}.navbar.is-fixed-bottom-desktop{bottom:0}.navbar.is-fixed-bottom-desktop.has-shadow{-webkit-box-shadow:0 -2px 3px rgba(10,10,10,.1);box-shadow:0 -2px 3px rgba(10,10,10,.1)}.navbar.is-fixed-top-desktop{top:0}html.has-navbar-fixed-top-desktop{padding-top:3.25rem}html.has-navbar-fixed-bottom-desktop{padding-bottom:3.25rem}a.navbar-item.is-active,a.navbar-link.is-active{color:#0a0a0a}a.navbar-item.is-active:not(:hover),a.navbar-link.is-active:not(:hover){background-color:transparent}.navbar-item.has-dropdown.is-active .navbar-link,.navbar-item.has-dropdown:hover .navbar-link{background-color:#f5f5f5}}.pagination{font-size:1rem;margin:-.25rem}.pagination.is-small{font-size:.75rem}.pagination.is-medium{font-size:1.25rem}.pagination.is-large{font-size:1.5rem}.pagination.is-rounded .pagination-next,.pagination.is-rounded .pagination-previous{padding-left:1em;padding-right:1em;border-radius:290486px}.pagination.is-rounded .pagination-link{border-radius:290486px}.pagination,.pagination-list{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;text-align:center}.pagination-ellipsis,.pagination-link,.pagination-next,.pagination-previous{-moz-appearance:none;-webkit-appearance:none;-webkit-box-align:center;-ms-flex-align:center;align-items:center;border:1px solid transparent;border-radius:3px;-webkit-box-shadow:none;box-shadow:none;display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-flex;font-size:1rem;height:2.25em;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start;line-height:1.5;padding-bottom:calc(.375em - 1px);padding-left:calc(.625em - 1px);padding-right:calc(.625em - 1px);padding-top:calc(.375em - 1px);position:relative;vertical-align:top;-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;font-size:1em;padding-left:.5em;padding-right:.5em;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;margin:.25rem;text-align:center}.pagination-ellipsis.is-active,.pagination-ellipsis.is-focused,.pagination-ellipsis:active,.pagination-ellipsis:focus,.pagination-link.is-active,.pagination-link.is-focused,.pagination-link:active,.pagination-link:focus,.pagination-next.is-active,.pagination-next.is-focused,.pagination-next:active,.pagination-next:focus,.pagination-previous.is-active,.pagination-previous.is-focused,.pagination-previous:active,.pagination-previous:focus{outline:0}.pagination-ellipsis[disabled],.pagination-link[disabled],.pagination-next[disabled],.pagination-previous[disabled]{cursor:not-allowed}.pagination-link,.pagination-next,.pagination-previous{border-color:#dbdbdb;color:#363636;min-width:2.25em}.pagination-link:hover,.pagination-next:hover,.pagination-previous:hover{border-color:#b5b5b5;color:#363636}.pagination-link:focus,.pagination-next:focus,.pagination-previous:focus{border-color:#3273dc}.pagination-link:active,.pagination-next:active,.pagination-previous:active{-webkit-box-shadow:inset 0 1px 2px rgba(10,10,10,.2);box-shadow:inset 0 1px 2px rgba(10,10,10,.2)}.pagination-link[disabled],.pagination-next[disabled],.pagination-previous[disabled]{background-color:#dbdbdb;border-color:#dbdbdb;-webkit-box-shadow:none;box-shadow:none;color:#7a7a7a;opacity:.5}.pagination-next,.pagination-previous{padding-left:.75em;padding-right:.75em;white-space:nowrap}.pagination-link.is-current{background-color:#3273dc;border-color:#3273dc;color:#fff}.pagination-ellipsis{color:#b5b5b5;pointer-events:none}.pagination-list{-ms-flex-wrap:wrap;flex-wrap:wrap}@media screen and (max-width:768px){.pagination{-ms-flex-wrap:wrap;flex-wrap:wrap}.pagination-next,.pagination-previous{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}.pagination-list li{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}}@media screen and (min-width:769px),print{.pagination-list{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start;-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.pagination-previous{-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.pagination-next{-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}.pagination{-webkit-box-pack:justify;-ms-flex-pack:justify;justify-content:space-between}.pagination.is-centered .pagination-previous{-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.pagination.is-centered .pagination-list{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.pagination.is-centered .pagination-next{-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}.pagination.is-right .pagination-previous{-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.pagination.is-right .pagination-next{-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.pagination.is-right .pagination-list{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end;-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}}.panel{font-size:1rem}.panel:not(:last-child){margin-bottom:1.5rem}.panel-block,.panel-heading,.panel-tabs{border-bottom:1px solid #dbdbdb;border-left:1px solid #dbdbdb;border-right:1px solid #dbdbdb}.panel-block:first-child,.panel-heading:first-child,.panel-tabs:first-child{border-top:1px solid #dbdbdb}.panel-heading{background-color:#f5f5f5;border-radius:3px 3px 0 0;color:#363636;font-size:1.25em;font-weight:300;line-height:1.25;padding:.5em .75em}.panel-tabs{-webkit-box-align:end;-ms-flex-align:end;align-items:flex-end;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:.875em;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.panel-tabs a{border-bottom:1px solid #dbdbdb;margin-bottom:-1px;padding:.5em}.panel-tabs a.is-active{border-bottom-color:#4a4a4a;color:#363636}.panel-list a{color:#4a4a4a}.panel-list a:hover{color:#3273dc}.panel-block{-webkit-box-align:center;-ms-flex-align:center;align-items:center;color:#363636;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start;padding:.5em .75em}.panel-block input[type=checkbox]{margin-right:.75em}.panel-block>.control{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;width:100%}.panel-block.is-wrapped{-ms-flex-wrap:wrap;flex-wrap:wrap}.panel-block.is-active{border-left-color:#3273dc;color:#363636}.panel-block.is-active .panel-icon{color:#3273dc}a.panel-block,label.panel-block{cursor:pointer}a.panel-block:hover,label.panel-block:hover{background-color:#f5f5f5}.panel-icon{display:inline-block;font-size:14px;height:1em;line-height:1em;text-align:center;vertical-align:top;width:1em;color:#7a7a7a;margin-right:.75em}.panel-icon .fa{font-size:inherit;line-height:inherit}.tabs{-webkit-overflow-scrolling:touch;-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:1rem;-webkit-box-pack:justify;-ms-flex-pack:justify;justify-content:space-between;overflow:hidden;overflow-x:auto;white-space:nowrap}.tabs:not(:last-child){margin-bottom:1.5rem}.tabs a{-webkit-box-align:center;-ms-flex-align:center;align-items:center;border-bottom-color:#dbdbdb;border-bottom-style:solid;border-bottom-width:1px;color:#4a4a4a;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;margin-bottom:-1px;padding:.5em 1em;vertical-align:top}.tabs a:hover{border-bottom-color:#363636;color:#363636}.tabs li{display:block}.tabs li.is-active a{border-bottom-color:#3273dc;color:#3273dc}.tabs ul{-webkit-box-align:center;-ms-flex-align:center;align-items:center;border-bottom-color:#dbdbdb;border-bottom-style:solid;border-bottom-width:1px;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;-webkit-box-pack:start;-ms-flex-pack:start;justify-content:flex-start}.tabs ul.is-left{padding-right:.75em}.tabs ul.is-center{-webkit-box-flex:0;-ms-flex:none;flex:none;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;padding-left:.75em;padding-right:.75em}.tabs ul.is-right{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end;padding-left:.75em}.tabs .icon:first-child{margin-right:.5em}.tabs .icon:last-child{margin-left:.5em}.tabs.is-centered ul{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.tabs.is-right ul{-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end}.tabs.is-boxed a{border:1px solid transparent;border-radius:3px 3px 0 0}.tabs.is-boxed a:hover{background-color:#f5f5f5;border-bottom-color:#dbdbdb}.tabs.is-boxed li.is-active a{background-color:#fff;border-color:#dbdbdb;border-bottom-color:transparent!important}.tabs.is-fullwidth li{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0}.tabs.is-toggle a{border-color:#dbdbdb;border-style:solid;border-width:1px;margin-bottom:0;position:relative}.tabs.is-toggle a:hover{background-color:#f5f5f5;border-color:#b5b5b5;z-index:2}.tabs.is-toggle li+li{margin-left:-1px}.tabs.is-toggle li:first-child a{border-radius:3px 0 0 3px}.tabs.is-toggle li:last-child a{border-radius:0 3px 3px 0}.tabs.is-toggle li.is-active a{background-color:#3273dc;border-color:#3273dc;color:#fff;z-index:1}.tabs.is-toggle ul{border-bottom:none}.tabs.is-toggle.is-toggle-rounded li:first-child a{border-bottom-left-radius:290486px;border-top-left-radius:290486px;padding-left:1.25em}.tabs.is-toggle.is-toggle-rounded li:last-child a{border-bottom-right-radius:290486px;border-top-right-radius:290486px;padding-right:1.25em}.tabs.is-small{font-size:.75rem}.tabs.is-medium{font-size:1.25rem}.tabs.is-large{font-size:1.5rem}.column{display:block;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;padding:.75rem}.columns.is-mobile>.column.is-narrow{-webkit-box-flex:0;-ms-flex:none;flex:none}.columns.is-mobile>.column.is-full{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.columns.is-mobile>.column.is-three-quarters{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.columns.is-mobile>.column.is-two-thirds{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.columns.is-mobile>.column.is-half{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.columns.is-mobile>.column.is-one-third{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.columns.is-mobile>.column.is-one-quarter{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.columns.is-mobile>.column.is-one-fifth{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.columns.is-mobile>.column.is-two-fifths{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.columns.is-mobile>.column.is-three-fifths{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.columns.is-mobile>.column.is-four-fifths{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.columns.is-mobile>.column.is-offset-three-quarters{margin-left:75%}.columns.is-mobile>.column.is-offset-two-thirds{margin-left:66.6666%}.columns.is-mobile>.column.is-offset-half{margin-left:50%}.columns.is-mobile>.column.is-offset-one-third{margin-left:33.3333%}.columns.is-mobile>.column.is-offset-one-quarter{margin-left:25%}.columns.is-mobile>.column.is-offset-one-fifth{margin-left:20%}.columns.is-mobile>.column.is-offset-two-fifths{margin-left:40%}.columns.is-mobile>.column.is-offset-three-fifths{margin-left:60%}.columns.is-mobile>.column.is-offset-four-fifths{margin-left:80%}.columns.is-mobile>.column.is-1{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.columns.is-mobile>.column.is-offset-1{margin-left:8.33333%}.columns.is-mobile>.column.is-2{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.columns.is-mobile>.column.is-offset-2{margin-left:16.66667%}.columns.is-mobile>.column.is-3{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.columns.is-mobile>.column.is-offset-3{margin-left:25%}.columns.is-mobile>.column.is-4{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.columns.is-mobile>.column.is-offset-4{margin-left:33.33333%}.columns.is-mobile>.column.is-5{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.columns.is-mobile>.column.is-offset-5{margin-left:41.66667%}.columns.is-mobile>.column.is-6{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.columns.is-mobile>.column.is-offset-6{margin-left:50%}.columns.is-mobile>.column.is-7{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.columns.is-mobile>.column.is-offset-7{margin-left:58.33333%}.columns.is-mobile>.column.is-8{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.columns.is-mobile>.column.is-offset-8{margin-left:66.66667%}.columns.is-mobile>.column.is-9{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.columns.is-mobile>.column.is-offset-9{margin-left:75%}.columns.is-mobile>.column.is-10{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.columns.is-mobile>.column.is-offset-10{margin-left:83.33333%}.columns.is-mobile>.column.is-11{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.columns.is-mobile>.column.is-offset-11{margin-left:91.66667%}.columns.is-mobile>.column.is-12{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.columns.is-mobile>.column.is-offset-12{margin-left:100%}@media screen and (max-width:768px){.column.is-narrow-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters-mobile{margin-left:75%}.column.is-offset-two-thirds-mobile{margin-left:66.6666%}.column.is-offset-half-mobile{margin-left:50%}.column.is-offset-one-third-mobile{margin-left:33.3333%}.column.is-offset-one-quarter-mobile{margin-left:25%}.column.is-offset-one-fifth-mobile{margin-left:20%}.column.is-offset-two-fifths-mobile{margin-left:40%}.column.is-offset-three-fifths-mobile{margin-left:60%}.column.is-offset-four-fifths-mobile{margin-left:80%}.column.is-1-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1-mobile{margin-left:8.33333%}.column.is-2-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2-mobile{margin-left:16.66667%}.column.is-3-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3-mobile{margin-left:25%}.column.is-4-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4-mobile{margin-left:33.33333%}.column.is-5-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5-mobile{margin-left:41.66667%}.column.is-6-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6-mobile{margin-left:50%}.column.is-7-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7-mobile{margin-left:58.33333%}.column.is-8-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8-mobile{margin-left:66.66667%}.column.is-9-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9-mobile{margin-left:75%}.column.is-10-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10-mobile{margin-left:83.33333%}.column.is-11-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11-mobile{margin-left:91.66667%}.column.is-12-mobile{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12-mobile{margin-left:100%}}@media screen and (min-width:769px),print{.column.is-narrow,.column.is-narrow-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full,.column.is-full-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters,.column.is-three-quarters-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds,.column.is-two-thirds-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half,.column.is-half-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third,.column.is-one-third-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter,.column.is-one-quarter-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth,.column.is-one-fifth-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths,.column.is-two-fifths-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths,.column.is-three-fifths-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths,.column.is-four-fifths-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters,.column.is-offset-three-quarters-tablet{margin-left:75%}.column.is-offset-two-thirds,.column.is-offset-two-thirds-tablet{margin-left:66.6666%}.column.is-offset-half,.column.is-offset-half-tablet{margin-left:50%}.column.is-offset-one-third,.column.is-offset-one-third-tablet{margin-left:33.3333%}.column.is-offset-one-quarter,.column.is-offset-one-quarter-tablet{margin-left:25%}.column.is-offset-one-fifth,.column.is-offset-one-fifth-tablet{margin-left:20%}.column.is-offset-two-fifths,.column.is-offset-two-fifths-tablet{margin-left:40%}.column.is-offset-three-fifths,.column.is-offset-three-fifths-tablet{margin-left:60%}.column.is-offset-four-fifths,.column.is-offset-four-fifths-tablet{margin-left:80%}.column.is-1,.column.is-1-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1,.column.is-offset-1-tablet{margin-left:8.33333%}.column.is-2,.column.is-2-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2,.column.is-offset-2-tablet{margin-left:16.66667%}.column.is-3,.column.is-3-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3,.column.is-offset-3-tablet{margin-left:25%}.column.is-4,.column.is-4-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4,.column.is-offset-4-tablet{margin-left:33.33333%}.column.is-5,.column.is-5-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5,.column.is-offset-5-tablet{margin-left:41.66667%}.column.is-6,.column.is-6-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6,.column.is-offset-6-tablet{margin-left:50%}.column.is-7,.column.is-7-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7,.column.is-offset-7-tablet{margin-left:58.33333%}.column.is-8,.column.is-8-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8,.column.is-offset-8-tablet{margin-left:66.66667%}.column.is-9,.column.is-9-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9,.column.is-offset-9-tablet{margin-left:75%}.column.is-10,.column.is-10-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10,.column.is-offset-10-tablet{margin-left:83.33333%}.column.is-11,.column.is-11-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11,.column.is-offset-11-tablet{margin-left:91.66667%}.column.is-12,.column.is-12-tablet{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12,.column.is-offset-12-tablet{margin-left:100%}}@media screen and (max-width:1023px){.column.is-narrow-touch{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters-touch{margin-left:75%}.column.is-offset-two-thirds-touch{margin-left:66.6666%}.column.is-offset-half-touch{margin-left:50%}.column.is-offset-one-third-touch{margin-left:33.3333%}.column.is-offset-one-quarter-touch{margin-left:25%}.column.is-offset-one-fifth-touch{margin-left:20%}.column.is-offset-two-fifths-touch{margin-left:40%}.column.is-offset-three-fifths-touch{margin-left:60%}.column.is-offset-four-fifths-touch{margin-left:80%}.column.is-1-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1-touch{margin-left:8.33333%}.column.is-2-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2-touch{margin-left:16.66667%}.column.is-3-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3-touch{margin-left:25%}.column.is-4-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4-touch{margin-left:33.33333%}.column.is-5-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5-touch{margin-left:41.66667%}.column.is-6-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6-touch{margin-left:50%}.column.is-7-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7-touch{margin-left:58.33333%}.column.is-8-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8-touch{margin-left:66.66667%}.column.is-9-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9-touch{margin-left:75%}.column.is-10-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10-touch{margin-left:83.33333%}.column.is-11-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11-touch{margin-left:91.66667%}.column.is-12-touch{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12-touch{margin-left:100%}}@media screen and (min-width:1024px){.column.is-narrow-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters-desktop{margin-left:75%}.column.is-offset-two-thirds-desktop{margin-left:66.6666%}.column.is-offset-half-desktop{margin-left:50%}.column.is-offset-one-third-desktop{margin-left:33.3333%}.column.is-offset-one-quarter-desktop{margin-left:25%}.column.is-offset-one-fifth-desktop{margin-left:20%}.column.is-offset-two-fifths-desktop{margin-left:40%}.column.is-offset-three-fifths-desktop{margin-left:60%}.column.is-offset-four-fifths-desktop{margin-left:80%}.column.is-1-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1-desktop{margin-left:8.33333%}.column.is-2-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2-desktop{margin-left:16.66667%}.column.is-3-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3-desktop{margin-left:25%}.column.is-4-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4-desktop{margin-left:33.33333%}.column.is-5-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5-desktop{margin-left:41.66667%}.column.is-6-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6-desktop{margin-left:50%}.column.is-7-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7-desktop{margin-left:58.33333%}.column.is-8-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8-desktop{margin-left:66.66667%}.column.is-9-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9-desktop{margin-left:75%}.column.is-10-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10-desktop{margin-left:83.33333%}.column.is-11-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11-desktop{margin-left:91.66667%}.column.is-12-desktop{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12-desktop{margin-left:100%}}@media screen and (min-width:1216px){.column.is-narrow-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters-widescreen{margin-left:75%}.column.is-offset-two-thirds-widescreen{margin-left:66.6666%}.column.is-offset-half-widescreen{margin-left:50%}.column.is-offset-one-third-widescreen{margin-left:33.3333%}.column.is-offset-one-quarter-widescreen{margin-left:25%}.column.is-offset-one-fifth-widescreen{margin-left:20%}.column.is-offset-two-fifths-widescreen{margin-left:40%}.column.is-offset-three-fifths-widescreen{margin-left:60%}.column.is-offset-four-fifths-widescreen{margin-left:80%}.column.is-1-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1-widescreen{margin-left:8.33333%}.column.is-2-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2-widescreen{margin-left:16.66667%}.column.is-3-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3-widescreen{margin-left:25%}.column.is-4-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4-widescreen{margin-left:33.33333%}.column.is-5-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5-widescreen{margin-left:41.66667%}.column.is-6-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6-widescreen{margin-left:50%}.column.is-7-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7-widescreen{margin-left:58.33333%}.column.is-8-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8-widescreen{margin-left:66.66667%}.column.is-9-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9-widescreen{margin-left:75%}.column.is-10-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10-widescreen{margin-left:83.33333%}.column.is-11-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11-widescreen{margin-left:91.66667%}.column.is-12-widescreen{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12-widescreen{margin-left:100%}}@media screen and (min-width:1408px){.column.is-narrow-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none}.column.is-full-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-three-quarters-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-two-thirds-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.6666%}.column.is-half-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-one-third-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.3333%}.column.is-one-quarter-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-one-fifth-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:20%}.column.is-two-fifths-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:40%}.column.is-three-fifths-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:60%}.column.is-four-fifths-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:80%}.column.is-offset-three-quarters-fullhd{margin-left:75%}.column.is-offset-two-thirds-fullhd{margin-left:66.6666%}.column.is-offset-half-fullhd{margin-left:50%}.column.is-offset-one-third-fullhd{margin-left:33.3333%}.column.is-offset-one-quarter-fullhd{margin-left:25%}.column.is-offset-one-fifth-fullhd{margin-left:20%}.column.is-offset-two-fifths-fullhd{margin-left:40%}.column.is-offset-three-fifths-fullhd{margin-left:60%}.column.is-offset-four-fifths-fullhd{margin-left:80%}.column.is-1-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.column.is-offset-1-fullhd{margin-left:8.33333%}.column.is-2-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.column.is-offset-2-fullhd{margin-left:16.66667%}.column.is-3-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.column.is-offset-3-fullhd{margin-left:25%}.column.is-4-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.column.is-offset-4-fullhd{margin-left:33.33333%}.column.is-5-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.column.is-offset-5-fullhd{margin-left:41.66667%}.column.is-6-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.column.is-offset-6-fullhd{margin-left:50%}.column.is-7-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.column.is-offset-7-fullhd{margin-left:58.33333%}.column.is-8-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.column.is-offset-8-fullhd{margin-left:66.66667%}.column.is-9-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.column.is-offset-9-fullhd{margin-left:75%}.column.is-10-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.column.is-offset-10-fullhd{margin-left:83.33333%}.column.is-11-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.column.is-offset-11-fullhd{margin-left:91.66667%}.column.is-12-fullhd{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}.column.is-offset-12-fullhd{margin-left:100%}}.columns{margin-left:-.75rem;margin-right:-.75rem;margin-top:-.75rem}.columns:last-child{margin-bottom:-.75rem}.columns:not(:last-child){margin-bottom:calc(1.5rem - .75rem)}.columns.is-centered{-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.columns.is-gapless{margin-left:0;margin-right:0;margin-top:0}.columns.is-gapless>.column{margin:0;padding:0!important}.columns.is-gapless:not(:last-child){margin-bottom:1.5rem}.columns.is-gapless:last-child{margin-bottom:0}.columns.is-mobile{display:-webkit-box;display:-ms-flexbox;display:flex}.columns.is-multiline{-ms-flex-wrap:wrap;flex-wrap:wrap}.columns.is-vcentered{-webkit-box-align:center;-ms-flex-align:center;align-items:center}@media screen and (min-width:769px),print{.columns:not(.is-desktop){display:-webkit-box;display:-ms-flexbox;display:flex}}@media screen and (min-width:1024px){.columns.is-desktop{display:-webkit-box;display:-ms-flexbox;display:flex}}.columns.is-variable{--columnGap:0.75rem;margin-left:calc(-1 * var(--columnGap));margin-right:calc(-1 * var(--columnGap))}.columns.is-variable .column{padding-left:var(--columnGap);padding-right:var(--columnGap)}.columns.is-variable.is-0{--columnGap:0rem}.columns.is-variable.is-1{--columnGap:0.25rem}.columns.is-variable.is-2{--columnGap:0.5rem}.columns.is-variable.is-3{--columnGap:0.75rem}.columns.is-variable.is-4{--columnGap:1rem}.columns.is-variable.is-5{--columnGap:1.25rem}.columns.is-variable.is-6{--columnGap:1.5rem}.columns.is-variable.is-7{--columnGap:1.75rem}.columns.is-variable.is-8{--columnGap:2rem}.tile{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:block;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1;min-height:-webkit-min-content;min-height:-moz-min-content;min-height:min-content}.tile.is-ancestor{margin-left:-.75rem;margin-right:-.75rem;margin-top:-.75rem}.tile.is-ancestor:last-child{margin-bottom:-.75rem}.tile.is-ancestor:not(:last-child){margin-bottom:.75rem}.tile.is-child{margin:0!important}.tile.is-parent{padding:.75rem}.tile.is-vertical{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.tile.is-vertical>.tile.is-child:not(:last-child){margin-bottom:1.5rem!important}@media screen and (min-width:769px),print{.tile:not(.is-child){display:-webkit-box;display:-ms-flexbox;display:flex}.tile.is-1{-webkit-box-flex:0;-ms-flex:none;flex:none;width:8.33333%}.tile.is-2{-webkit-box-flex:0;-ms-flex:none;flex:none;width:16.66667%}.tile.is-3{-webkit-box-flex:0;-ms-flex:none;flex:none;width:25%}.tile.is-4{-webkit-box-flex:0;-ms-flex:none;flex:none;width:33.33333%}.tile.is-5{-webkit-box-flex:0;-ms-flex:none;flex:none;width:41.66667%}.tile.is-6{-webkit-box-flex:0;-ms-flex:none;flex:none;width:50%}.tile.is-7{-webkit-box-flex:0;-ms-flex:none;flex:none;width:58.33333%}.tile.is-8{-webkit-box-flex:0;-ms-flex:none;flex:none;width:66.66667%}.tile.is-9{-webkit-box-flex:0;-ms-flex:none;flex:none;width:75%}.tile.is-10{-webkit-box-flex:0;-ms-flex:none;flex:none;width:83.33333%}.tile.is-11{-webkit-box-flex:0;-ms-flex:none;flex:none;width:91.66667%}.tile.is-12{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%}}.hero{-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;-webkit-box-pack:justify;-ms-flex-pack:justify;justify-content:space-between}.hero .navbar{background:0 0}.hero .tabs ul{border-bottom:none}.hero.is-white{background-color:#fff;color:#0a0a0a}.hero.is-white a:not(.button):not(.dropdown-item):not(.tag),.hero.is-white strong{color:inherit}.hero.is-white .title{color:#0a0a0a}.hero.is-white .subtitle{color:rgba(10,10,10,.9)}.hero.is-white .subtitle a:not(.button),.hero.is-white .subtitle strong{color:#0a0a0a}@media screen and (max-width:1023px){.hero.is-white .navbar-menu{background-color:#fff}}.hero.is-white .navbar-item,.hero.is-white .navbar-link{color:rgba(10,10,10,.7)}.hero.is-white .navbar-link.is-active,.hero.is-white .navbar-link:hover,.hero.is-white a.navbar-item.is-active,.hero.is-white a.navbar-item:hover{background-color:#f2f2f2;color:#0a0a0a}.hero.is-white .tabs a{color:#0a0a0a;opacity:.9}.hero.is-white .tabs a:hover{opacity:1}.hero.is-white .tabs li.is-active a{opacity:1}.hero.is-white .tabs.is-boxed a,.hero.is-white .tabs.is-toggle a{color:#0a0a0a}.hero.is-white .tabs.is-boxed a:hover,.hero.is-white .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-white .tabs.is-boxed li.is-active a,.hero.is-white .tabs.is-boxed li.is-active a:hover,.hero.is-white .tabs.is-toggle li.is-active a,.hero.is-white .tabs.is-toggle li.is-active a:hover{background-color:#0a0a0a;border-color:#0a0a0a;color:#fff}.hero.is-white.is-bold{background-image:linear-gradient(141deg,#e6e6e6 0,#fff 71%,#fff 100%)}@media screen and (max-width:768px){.hero.is-white.is-bold .navbar-menu{background-image:linear-gradient(141deg,#e6e6e6 0,#fff 71%,#fff 100%)}}.hero.is-black{background-color:#0a0a0a;color:#fff}.hero.is-black a:not(.button):not(.dropdown-item):not(.tag),.hero.is-black strong{color:inherit}.hero.is-black .title{color:#fff}.hero.is-black .subtitle{color:rgba(255,255,255,.9)}.hero.is-black .subtitle a:not(.button),.hero.is-black .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-black .navbar-menu{background-color:#0a0a0a}}.hero.is-black .navbar-item,.hero.is-black .navbar-link{color:rgba(255,255,255,.7)}.hero.is-black .navbar-link.is-active,.hero.is-black .navbar-link:hover,.hero.is-black a.navbar-item.is-active,.hero.is-black a.navbar-item:hover{background-color:#000;color:#fff}.hero.is-black .tabs a{color:#fff;opacity:.9}.hero.is-black .tabs a:hover{opacity:1}.hero.is-black .tabs li.is-active a{opacity:1}.hero.is-black .tabs.is-boxed a,.hero.is-black .tabs.is-toggle a{color:#fff}.hero.is-black .tabs.is-boxed a:hover,.hero.is-black .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-black .tabs.is-boxed li.is-active a,.hero.is-black .tabs.is-boxed li.is-active a:hover,.hero.is-black .tabs.is-toggle li.is-active a,.hero.is-black .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#0a0a0a}.hero.is-black.is-bold{background-image:linear-gradient(141deg,#000 0,#0a0a0a 71%,#181616 100%)}@media screen and (max-width:768px){.hero.is-black.is-bold .navbar-menu{background-image:linear-gradient(141deg,#000 0,#0a0a0a 71%,#181616 100%)}}.hero.is-light{background-color:#f5f5f5;color:#363636}.hero.is-light a:not(.button):not(.dropdown-item):not(.tag),.hero.is-light strong{color:inherit}.hero.is-light .title{color:#363636}.hero.is-light .subtitle{color:rgba(54,54,54,.9)}.hero.is-light .subtitle a:not(.button),.hero.is-light .subtitle strong{color:#363636}@media screen and (max-width:1023px){.hero.is-light .navbar-menu{background-color:#f5f5f5}}.hero.is-light .navbar-item,.hero.is-light .navbar-link{color:rgba(54,54,54,.7)}.hero.is-light .navbar-link.is-active,.hero.is-light .navbar-link:hover,.hero.is-light a.navbar-item.is-active,.hero.is-light a.navbar-item:hover{background-color:#e8e8e8;color:#363636}.hero.is-light .tabs a{color:#363636;opacity:.9}.hero.is-light .tabs a:hover{opacity:1}.hero.is-light .tabs li.is-active a{opacity:1}.hero.is-light .tabs.is-boxed a,.hero.is-light .tabs.is-toggle a{color:#363636}.hero.is-light .tabs.is-boxed a:hover,.hero.is-light .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-light .tabs.is-boxed li.is-active a,.hero.is-light .tabs.is-boxed li.is-active a:hover,.hero.is-light .tabs.is-toggle li.is-active a,.hero.is-light .tabs.is-toggle li.is-active a:hover{background-color:#363636;border-color:#363636;color:#f5f5f5}.hero.is-light.is-bold{background-image:linear-gradient(141deg,#dfd8d9 0,#f5f5f5 71%,#fff 100%)}@media screen and (max-width:768px){.hero.is-light.is-bold .navbar-menu{background-image:linear-gradient(141deg,#dfd8d9 0,#f5f5f5 71%,#fff 100%)}}.hero.is-dark{background-color:#363636;color:#f5f5f5}.hero.is-dark a:not(.button):not(.dropdown-item):not(.tag),.hero.is-dark strong{color:inherit}.hero.is-dark .title{color:#f5f5f5}.hero.is-dark .subtitle{color:rgba(245,245,245,.9)}.hero.is-dark .subtitle a:not(.button),.hero.is-dark .subtitle strong{color:#f5f5f5}@media screen and (max-width:1023px){.hero.is-dark .navbar-menu{background-color:#363636}}.hero.is-dark .navbar-item,.hero.is-dark .navbar-link{color:rgba(245,245,245,.7)}.hero.is-dark .navbar-link.is-active,.hero.is-dark .navbar-link:hover,.hero.is-dark a.navbar-item.is-active,.hero.is-dark a.navbar-item:hover{background-color:#292929;color:#f5f5f5}.hero.is-dark .tabs a{color:#f5f5f5;opacity:.9}.hero.is-dark .tabs a:hover{opacity:1}.hero.is-dark .tabs li.is-active a{opacity:1}.hero.is-dark .tabs.is-boxed a,.hero.is-dark .tabs.is-toggle a{color:#f5f5f5}.hero.is-dark .tabs.is-boxed a:hover,.hero.is-dark .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-dark .tabs.is-boxed li.is-active a,.hero.is-dark .tabs.is-boxed li.is-active a:hover,.hero.is-dark .tabs.is-toggle li.is-active a,.hero.is-dark .tabs.is-toggle li.is-active a:hover{background-color:#f5f5f5;border-color:#f5f5f5;color:#363636}.hero.is-dark.is-bold{background-image:linear-gradient(141deg,#1f191a 0,#363636 71%,#46403f 100%)}@media screen and (max-width:768px){.hero.is-dark.is-bold .navbar-menu{background-image:linear-gradient(141deg,#1f191a 0,#363636 71%,#46403f 100%)}}.hero.is-primary{background-color:#00d1b2;color:#fff}.hero.is-primary a:not(.button):not(.dropdown-item):not(.tag),.hero.is-primary strong{color:inherit}.hero.is-primary .title{color:#fff}.hero.is-primary .subtitle{color:rgba(255,255,255,.9)}.hero.is-primary .subtitle a:not(.button),.hero.is-primary .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-primary .navbar-menu{background-color:#00d1b2}}.hero.is-primary .navbar-item,.hero.is-primary .navbar-link{color:rgba(255,255,255,.7)}.hero.is-primary .navbar-link.is-active,.hero.is-primary .navbar-link:hover,.hero.is-primary a.navbar-item.is-active,.hero.is-primary a.navbar-item:hover{background-color:#00b89c;color:#fff}.hero.is-primary .tabs a{color:#fff;opacity:.9}.hero.is-primary .tabs a:hover{opacity:1}.hero.is-primary .tabs li.is-active a{opacity:1}.hero.is-primary .tabs.is-boxed a,.hero.is-primary .tabs.is-toggle a{color:#fff}.hero.is-primary .tabs.is-boxed a:hover,.hero.is-primary .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-primary .tabs.is-boxed li.is-active a,.hero.is-primary .tabs.is-boxed li.is-active a:hover,.hero.is-primary .tabs.is-toggle li.is-active a,.hero.is-primary .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#00d1b2}.hero.is-primary.is-bold{background-image:linear-gradient(141deg,#009e6c 0,#00d1b2 71%,#00e7eb 100%)}@media screen and (max-width:768px){.hero.is-primary.is-bold .navbar-menu{background-image:linear-gradient(141deg,#009e6c 0,#00d1b2 71%,#00e7eb 100%)}}.hero.is-link{background-color:#3273dc;color:#fff}.hero.is-link a:not(.button):not(.dropdown-item):not(.tag),.hero.is-link strong{color:inherit}.hero.is-link .title{color:#fff}.hero.is-link .subtitle{color:rgba(255,255,255,.9)}.hero.is-link .subtitle a:not(.button),.hero.is-link .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-link .navbar-menu{background-color:#3273dc}}.hero.is-link .navbar-item,.hero.is-link .navbar-link{color:rgba(255,255,255,.7)}.hero.is-link .navbar-link.is-active,.hero.is-link .navbar-link:hover,.hero.is-link a.navbar-item.is-active,.hero.is-link a.navbar-item:hover{background-color:#2366d1;color:#fff}.hero.is-link .tabs a{color:#fff;opacity:.9}.hero.is-link .tabs a:hover{opacity:1}.hero.is-link .tabs li.is-active a{opacity:1}.hero.is-link .tabs.is-boxed a,.hero.is-link .tabs.is-toggle a{color:#fff}.hero.is-link .tabs.is-boxed a:hover,.hero.is-link .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-link .tabs.is-boxed li.is-active a,.hero.is-link .tabs.is-boxed li.is-active a:hover,.hero.is-link .tabs.is-toggle li.is-active a,.hero.is-link .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#3273dc}.hero.is-link.is-bold{background-image:linear-gradient(141deg,#1577c6 0,#3273dc 71%,#4366e5 100%)}@media screen and (max-width:768px){.hero.is-link.is-bold .navbar-menu{background-image:linear-gradient(141deg,#1577c6 0,#3273dc 71%,#4366e5 100%)}}.hero.is-info{background-color:#209cee;color:#fff}.hero.is-info a:not(.button):not(.dropdown-item):not(.tag),.hero.is-info strong{color:inherit}.hero.is-info .title{color:#fff}.hero.is-info .subtitle{color:rgba(255,255,255,.9)}.hero.is-info .subtitle a:not(.button),.hero.is-info .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-info .navbar-menu{background-color:#209cee}}.hero.is-info .navbar-item,.hero.is-info .navbar-link{color:rgba(255,255,255,.7)}.hero.is-info .navbar-link.is-active,.hero.is-info .navbar-link:hover,.hero.is-info a.navbar-item.is-active,.hero.is-info a.navbar-item:hover{background-color:#118fe4;color:#fff}.hero.is-info .tabs a{color:#fff;opacity:.9}.hero.is-info .tabs a:hover{opacity:1}.hero.is-info .tabs li.is-active a{opacity:1}.hero.is-info .tabs.is-boxed a,.hero.is-info .tabs.is-toggle a{color:#fff}.hero.is-info .tabs.is-boxed a:hover,.hero.is-info .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-info .tabs.is-boxed li.is-active a,.hero.is-info .tabs.is-boxed li.is-active a:hover,.hero.is-info .tabs.is-toggle li.is-active a,.hero.is-info .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#209cee}.hero.is-info.is-bold{background-image:linear-gradient(141deg,#04a6d7 0,#209cee 71%,#3287f5 100%)}@media screen and (max-width:768px){.hero.is-info.is-bold .navbar-menu{background-image:linear-gradient(141deg,#04a6d7 0,#209cee 71%,#3287f5 100%)}}.hero.is-success{background-color:#23d160;color:#fff}.hero.is-success a:not(.button):not(.dropdown-item):not(.tag),.hero.is-success strong{color:inherit}.hero.is-success .title{color:#fff}.hero.is-success .subtitle{color:rgba(255,255,255,.9)}.hero.is-success .subtitle a:not(.button),.hero.is-success .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-success .navbar-menu{background-color:#23d160}}.hero.is-success .navbar-item,.hero.is-success .navbar-link{color:rgba(255,255,255,.7)}.hero.is-success .navbar-link.is-active,.hero.is-success .navbar-link:hover,.hero.is-success a.navbar-item.is-active,.hero.is-success a.navbar-item:hover{background-color:#20bc56;color:#fff}.hero.is-success .tabs a{color:#fff;opacity:.9}.hero.is-success .tabs a:hover{opacity:1}.hero.is-success .tabs li.is-active a{opacity:1}.hero.is-success .tabs.is-boxed a,.hero.is-success .tabs.is-toggle a{color:#fff}.hero.is-success .tabs.is-boxed a:hover,.hero.is-success .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-success .tabs.is-boxed li.is-active a,.hero.is-success .tabs.is-boxed li.is-active a:hover,.hero.is-success .tabs.is-toggle li.is-active a,.hero.is-success .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#23d160}.hero.is-success.is-bold{background-image:linear-gradient(141deg,#12af2f 0,#23d160 71%,#2ce28a 100%)}@media screen and (max-width:768px){.hero.is-success.is-bold .navbar-menu{background-image:linear-gradient(141deg,#12af2f 0,#23d160 71%,#2ce28a 100%)}}.hero.is-warning{background-color:#ffdd57;color:rgba(0,0,0,.7)}.hero.is-warning a:not(.button):not(.dropdown-item):not(.tag),.hero.is-warning strong{color:inherit}.hero.is-warning .title{color:rgba(0,0,0,.7)}.hero.is-warning .subtitle{color:rgba(0,0,0,.9)}.hero.is-warning .subtitle a:not(.button),.hero.is-warning .subtitle strong{color:rgba(0,0,0,.7)}@media screen and (max-width:1023px){.hero.is-warning .navbar-menu{background-color:#ffdd57}}.hero.is-warning .navbar-item,.hero.is-warning .navbar-link{color:rgba(0,0,0,.7)}.hero.is-warning .navbar-link.is-active,.hero.is-warning .navbar-link:hover,.hero.is-warning a.navbar-item.is-active,.hero.is-warning a.navbar-item:hover{background-color:#ffd83d;color:rgba(0,0,0,.7)}.hero.is-warning .tabs a{color:rgba(0,0,0,.7);opacity:.9}.hero.is-warning .tabs a:hover{opacity:1}.hero.is-warning .tabs li.is-active a{opacity:1}.hero.is-warning .tabs.is-boxed a,.hero.is-warning .tabs.is-toggle a{color:rgba(0,0,0,.7)}.hero.is-warning .tabs.is-boxed a:hover,.hero.is-warning .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-warning .tabs.is-boxed li.is-active a,.hero.is-warning .tabs.is-boxed li.is-active a:hover,.hero.is-warning .tabs.is-toggle li.is-active a,.hero.is-warning .tabs.is-toggle li.is-active a:hover{background-color:rgba(0,0,0,.7);border-color:rgba(0,0,0,.7);color:#ffdd57}.hero.is-warning.is-bold{background-image:linear-gradient(141deg,#ffaf24 0,#ffdd57 71%,#fffa70 100%)}@media screen and (max-width:768px){.hero.is-warning.is-bold .navbar-menu{background-image:linear-gradient(141deg,#ffaf24 0,#ffdd57 71%,#fffa70 100%)}}.hero.is-danger{background-color:#ff3860;color:#fff}.hero.is-danger a:not(.button):not(.dropdown-item):not(.tag),.hero.is-danger strong{color:inherit}.hero.is-danger .title{color:#fff}.hero.is-danger .subtitle{color:rgba(255,255,255,.9)}.hero.is-danger .subtitle a:not(.button),.hero.is-danger .subtitle strong{color:#fff}@media screen and (max-width:1023px){.hero.is-danger .navbar-menu{background-color:#ff3860}}.hero.is-danger .navbar-item,.hero.is-danger .navbar-link{color:rgba(255,255,255,.7)}.hero.is-danger .navbar-link.is-active,.hero.is-danger .navbar-link:hover,.hero.is-danger a.navbar-item.is-active,.hero.is-danger a.navbar-item:hover{background-color:#ff1f4b;color:#fff}.hero.is-danger .tabs a{color:#fff;opacity:.9}.hero.is-danger .tabs a:hover{opacity:1}.hero.is-danger .tabs li.is-active a{opacity:1}.hero.is-danger .tabs.is-boxed a,.hero.is-danger .tabs.is-toggle a{color:#fff}.hero.is-danger .tabs.is-boxed a:hover,.hero.is-danger .tabs.is-toggle a:hover{background-color:rgba(10,10,10,.1)}.hero.is-danger .tabs.is-boxed li.is-active a,.hero.is-danger .tabs.is-boxed li.is-active a:hover,.hero.is-danger .tabs.is-toggle li.is-active a,.hero.is-danger .tabs.is-toggle li.is-active a:hover{background-color:#fff;border-color:#fff;color:#ff3860}.hero.is-danger.is-bold{background-image:linear-gradient(141deg,#ff0561 0,#ff3860 71%,#ff5257 100%)}@media screen and (max-width:768px){.hero.is-danger.is-bold .navbar-menu{background-image:linear-gradient(141deg,#ff0561 0,#ff3860 71%,#ff5257 100%)}}.hero.is-small .hero-body{padding-bottom:1.5rem;padding-top:1.5rem}@media screen and (min-width:769px),print{.hero.is-medium .hero-body{padding-bottom:9rem;padding-top:9rem}}@media screen and (min-width:769px),print{.hero.is-large .hero-body{padding-bottom:18rem;padding-top:18rem}}.hero.is-fullheight .hero-body,.hero.is-halfheight .hero-body{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex}.hero.is-fullheight .hero-body>.container,.hero.is-halfheight .hero-body>.container{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:1;flex-shrink:1}.hero.is-halfheight{min-height:50vh}.hero.is-fullheight{min-height:100vh}.hero-video{bottom:0;left:0;position:absolute;right:0;top:0;overflow:hidden}.hero-video video{left:50%;min-height:100%;min-width:100%;position:absolute;top:50%;-webkit-transform:translate3d(-50%,-50%,0);transform:translate3d(-50%,-50%,0)}.hero-video.is-transparent{opacity:.3}@media screen and (max-width:768px){.hero-video{display:none}}.hero-buttons{margin-top:1.5rem}@media screen and (max-width:768px){.hero-buttons .button{display:-webkit-box;display:-ms-flexbox;display:flex}.hero-buttons .button:not(:last-child){margin-bottom:.75rem}}@media screen and (min-width:769px),print{.hero-buttons{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.hero-buttons .button:not(:last-child){margin-right:1.5rem}}.hero-foot,.hero-head{-webkit-box-flex:0;-ms-flex-positive:0;flex-grow:0;-ms-flex-negative:0;flex-shrink:0}.hero-body{-webkit-box-flex:1;-ms-flex-positive:1;flex-grow:1;-ms-flex-negative:0;flex-shrink:0;padding:3rem 1.5rem}.section{padding:3rem 1.5rem}@media screen and (min-width:1024px){.section.is-medium{padding:9rem 1.5rem}.section.is-large{padding:18rem 1.5rem}}.footer{background-color:#f5f5f5;padding:3rem 1.5rem 6rem} +/*# sourceMappingURL=bulma.min.css.map */ \ No newline at end of file diff --git a/seminar06-planning/simulator/vendor/fontawesome-all.js b/seminar06-planning/simulator/vendor/fontawesome-all.js new file mode 100644 index 0000000..cfce431 --- /dev/null +++ b/seminar06-planning/simulator/vendor/fontawesome-all.js @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.0.8 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +!function(){"use strict";var c={};try{"undefined"!=typeof window&&(c=window)}catch(c){}var l=(c.navigator||{}).userAgent,h=void 0===l?"":l,v=c,z=(~h.indexOf("MSIE")||h.indexOf("Trident/"),"___FONT_AWESOME___"),e=function(){try{return!0}catch(c){return!1}}(),a=[1,2,3,4,5,6,7,8,9,10],m=a.concat([11,12,13,14,15,16,17,18,19,20]);["xs","sm","lg","fw","ul","li","border","pull-left","pull-right","spin","pulse","rotate-90","rotate-180","rotate-270","flip-horizontal","flip-vertical","stack","stack-1x","stack-2x","inverse","layers","layers-text","layers-counter"].concat(a.map(function(c){return c+"x"})).concat(m.map(function(c){return"w-"+c}));var t=v||{};t[z]||(t[z]={}),t[z].styles||(t[z].styles={}),t[z].hooks||(t[z].hooks={}),t[z].shims||(t[z].shims=[]);var s=t[z],r=Object.assign||function(c){for(var l=1;l1&&void 0!==arguments[1]?arguments[1]:{}).asNewDefault,h=void 0!==l&&l,v=Object.keys(O),z=h?function(c){return~v.indexOf(c)&&!~A.indexOf(c)}:function(c){return~v.indexOf(c)};Object.keys(c).forEach(function(l){z(l)&&(O[l]=c[l])})}m.FontAwesomeConfig=O;var N=m||{};N[n]||(N[n]={}),N[n].styles||(N[n].styles={}),N[n].hooks||(N[n].hooks={}),N[n].shims||(N[n].shims=[]);var E=N[n],P=[],_=!1;M&&((_=(t.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(t.readyState))||t.addEventListener("DOMContentLoaded",function c(){t.removeEventListener("DOMContentLoaded",c),_=1,P.map(function(c){return c()})}));var T=function(c){M&&(_?setTimeout(c,0):P.push(c))},F=H,I={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function R(c){if(c&&M){var l=t.createElement("style");l.setAttribute("type","text/css"),l.innerHTML=c;for(var h=t.head.childNodes,v=null,z=h.length-1;z>-1;z--){var e=h[z],a=(e.tagName||"").toUpperCase();["STYLE","LINK"].indexOf(a)>-1&&(v=e)}return t.head.insertBefore(l,v),c}}var W=0;function B(){return++W}function D(c){for(var l=[],h=(c||[]).length>>>0;h--;)l[h]=c[h];return l}function X(c){return c.classList?D(c.classList):(c.getAttribute("class")||"").split(" ").filter(function(c){return c})}function Y(c,l){var h,v=l.split("-"),z=v[0],e=v.slice(1).join("-");return z!==c||""===e||(h=e,~g.indexOf(h))?null:e}function U(c){return(""+c).replace(/&/g,"&").replace(/"/g,""").replace(/'/g,"'").replace(//g,">")}function K(c){return Object.keys(c||{}).reduce(function(l,h){return l+(h+": ")+c[h]+";"},"")}function G(c){return c.size!==I.size||c.x!==I.x||c.y!==I.y||c.rotate!==I.rotate||c.flipX||c.flipY}function J(c){var l=c.transform,h=c.containerWidth,v=c.iconWidth;return{outer:{transform:"translate("+h/2+" 256)"},inner:{transform:"translate("+32*l.x+", "+32*l.y+") "+" "+("scale("+l.size/16*(l.flipX?-1:1)+", "+l.size/16*(l.flipY?-1:1)+") ")+" "+("rotate("+l.rotate+" 0 0)")},path:{transform:"translate("+v/2*-1+" -256)"}}}var Q={x:0,y:0,width:"100%",height:"100%"},Z=function(c){var l=c.children,h=c.attributes,v=c.main,z=c.mask,e=c.transform,a=v.width,m=v.icon,t=z.width,s=z.icon,r=J({transform:e,containerWidth:t,iconWidth:a}),f={tag:"rect",attributes:k({},Q,{fill:"white"})},M={tag:"g",attributes:k({},r.inner),children:[{tag:"path",attributes:k({},m.attributes,r.path,{fill:"black"})}]},i={tag:"g",attributes:k({},r.outer),children:[M]},n="mask-"+B(),H="clip-"+B(),o={tag:"defs",children:[{tag:"clipPath",attributes:{id:H},children:[s]},{tag:"mask",attributes:k({},Q,{id:n,maskUnits:"userSpaceOnUse",maskContentUnits:"userSpaceOnUse"}),children:[f,i]}]};return l.push(o,{tag:"rect",attributes:k({fill:"currentColor","clip-path":"url(#"+H+")",mask:"url(#"+n+")"},Q)}),{children:l,attributes:h}},$=function(c){var l=c.children,h=c.attributes,v=c.main,z=c.transform,e=K(c.styles);if(e.length>0&&(h.style=e),G(z)){var a=J({transform:z,containerWidth:v.width,iconWidth:v.width});l.push({tag:"g",attributes:k({},a.outer),children:[{tag:"g",attributes:k({},a.inner),children:[{tag:v.icon.tag,children:v.icon.children,attributes:k({},v.icon.attributes,a.path)}]}]})}else l.push(v.icon);return{children:l,attributes:h}},cc=function(c){var l=c.children,h=c.main,v=c.mask,z=c.attributes,e=c.styles,a=c.transform;if(G(a)&&h.found&&!v.found){var m=h.width/h.height/2,t=.5;z.style=K(k({},e,{"transform-origin":m+a.x/16+"em "+(t+a.y/16)+"em"}))}return[{tag:"svg",attributes:z,children:l}]},lc=function(c){var l=c.prefix,h=c.iconName,v=c.children,z=c.attributes,e=c.symbol,a=!0===e?l+"-"+O.familyPrefix+"-"+h:e;return[{tag:"svg",attributes:{style:"display: none;"},children:[{tag:"symbol",attributes:k({},z,{id:a}),children:v}]}]};function hc(c){var l=c.icons,h=l.main,v=l.mask,z=c.prefix,e=c.iconName,a=c.transform,m=c.symbol,t=c.title,s=c.extra,r=c.watchable,f=void 0!==r&&r,M=v.found?v:h,i=M.width,n=M.height,H="fa-w-"+Math.ceil(i/n*16),o=[O.replacementClass,e?O.familyPrefix+"-"+e:"",H].concat(s.classes).join(" "),C={children:[],attributes:k({},s.attributes,{"data-prefix":z,"data-icon":e,class:o,role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 "+i+" "+n})};f&&(C.attributes[V]=""),t&&C.children.push({tag:"title",attributes:{id:C.attributes["aria-labelledby"]||"title-"+B()},children:[t]});var L=k({},C,{prefix:z,iconName:e,main:h,mask:v,transform:a,symbol:m,styles:s.styles}),u=v.found&&h.found?Z(L):$(L),d=u.children,p=u.attributes;return L.children=d,L.attributes=p,m?lc(L):cc(L)}function vc(c){var l=c.content,h=c.width,v=c.height,z=c.transform,e=c.title,a=c.extra,m=c.watchable,t=void 0!==m&&m,s=k({},a.attributes,e?{title:e}:{},{class:a.classes.join(" ")});t&&(s[V]="");var r,f,M,n,o,C,L,u,d,p=k({},a.styles);G(z)&&(p.transform=(f=(r={transform:z,startCentered:!0,width:h,height:v}).transform,M=r.width,n=void 0===M?H:M,o=r.height,C=void 0===o?H:o,L=r.startCentered,d="",d+=(u=void 0!==L&&L)&&i?"translate("+(f.x/F-n/2)+"em, "+(f.y/F-C/2)+"em) ":u?"translate(calc(-50% + "+f.x/F+"em), calc(-50% + "+f.y/F+"em)) ":"translate("+f.x/F+"em, "+f.y/F+"em) ",d+="scale("+f.size/F*(f.flipX?-1:1)+", "+f.size/F*(f.flipY?-1:1)+") ",d+="rotate("+f.rotate+"deg) "),p["-webkit-transform"]=p.transform);var b=K(p);b.length>0&&(s.style=b);var g=[];return g.push({tag:"span",attributes:s,children:[l]}),e&&g.push({tag:"span",attributes:{class:"sr-only"},children:[e]}),g}var zc=function(){},ec=O.measurePerformance&&r&&r.mark&&r.measure?r:{mark:zc,measure:zc},ac='FA "5.0.8"',mc=function(c){ec.mark(ac+" "+c+" ends"),ec.measure(ac+" "+c,ac+" "+c+" begins",ac+" "+c+" ends")},tc={begin:function(c){return ec.mark(ac+" "+c+" begins"),function(){return mc(c)}},end:mc},sc=function(c,l,h,v){var z,e,a,m,t,s=Object.keys(c),r=s.length,f=void 0!==v?(m=l,t=v,function(c,l,h,v){return m.call(t,c,l,h,v)}):l;for(void 0===h?(z=1,a=c[s[0]]):(z=0,a=h);z"+a.map(uc).join("")+""}var dc=function(){};function pc(c){return"string"==typeof(c.getAttribute?c.getAttribute(V):null)}var bc={replace:function(c){var l=c[0],h=c[1].map(function(c){return uc(c)}).join("\n");if(l.parentNode&&l.outerHTML)l.outerHTML=h+(O.keepOriginalSource&&"svg"!==l.tagName.toLowerCase()?"\x3c!-- "+l.outerHTML+" --\x3e":"");else if(l.parentNode){var v=document.createElement("span");l.parentNode.replaceChild(v,l),v.outerHTML=h}},nest:function(c){var l=c[0],h=c[1];if(~X(l).indexOf(O.replacementClass))return bc.replace(c);var v=new RegExp(O.familyPrefix+"-.*");delete h[0].attributes.style;var z=h[0].attributes.class.split(" ").reduce(function(c,l){return l===O.replacementClass||l.match(v)?c.toSvg.push(l):c.toNode.push(l),c},{toNode:[],toSvg:[]});h[0].attributes.class=z.toSvg.join(" ");var e=h.map(function(c){return uc(c)}).join("\n");l.setAttribute("class",z.toNode.join(" ")),l.setAttribute(V,""),l.innerHTML=e}};function gc(c,l){var h="function"==typeof l?l:dc;0===c.length?h():(m.requestAnimationFrame||function(c){return c()})(function(){var l=!0===O.autoReplaceSvg?bc.replace:bc[O.autoReplaceSvg]||bc.replace,v=tc.begin("mutate");c.map(l),v(),h()})}var yc=!1;var wc=null;var kc=function(c){var l=c.getAttribute("style"),h=[];return l&&(h=l.split(";").reduce(function(c,l){var h=l.split(":"),v=h[0],z=h.slice(1);return v&&z.length>0&&(c[v]=z.join(":").trim()),c},{})),h};var Sc=function(c){var l,h,v,z,e=c.getAttribute("data-prefix"),a=c.getAttribute("data-icon"),m=void 0!==c.innerText?c.innerText.trim():"",t=Cc(X(c));return e&&a&&(t.prefix=e,t.iconName=a),t.prefix&&m.length>1?t.iconName=(v=t.prefix,z=c.innerText,ic[v][z]):t.prefix&&1===m.length&&(t.iconName=(l=t.prefix,h=function(c){for(var l="",h=0;h-1&&Yc(z.nextSibling),Yc(z),z=null),v&&!z){var e=h.getPropertyValue("content"),a=t.createElement("i");a.setAttribute("class",""+Bc[v[1]]),a.setAttribute(C,l),a.innerText=3===e.length?e.substr(1,1):e,":before"===l?c.insertBefore(a,c.firstChild):c.appendChild(a)}})})}(),yc=!1,l()}}function Kc(c){var l=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(M){var h=t.documentElement.classList,v=function(c){return h.add(L+"-"+c)},z=function(c){return h.remove(L+"-"+c)},e=Object.keys(Ic),a=["."+Rc+":not(["+V+"])"].concat(e.map(function(c){return"."+c+":not(["+V+"])"})).join(", ");if(0!==a.length){var m=D(c.querySelectorAll(a));if(m.length>0){v("pending"),z("complete");var s=tc.begin("onTree"),r=m.reduce(function(c,l){try{var h=Xc(l);h&&c.push(h)}catch(c){u||c instanceof Nc&&console.error(c)}return c},[]);s(),gc(r,function(){v("active"),v("complete"),z("pending"),"function"==typeof l&&l()})}}}}function Gc(c){var l=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,h=Xc(c);h&&gc([h],l)}var Jc=function(){var c=o,l=O.familyPrefix,h=O.replacementClass,v="svg:not(:root).svg-inline--fa{overflow:visible}.svg-inline--fa{display:inline-block;font-size:inherit;height:1em;overflow:visible;vertical-align:-.125em}.svg-inline--fa.fa-lg{vertical-align:-.225em}.svg-inline--fa.fa-w-1{width:.0625em}.svg-inline--fa.fa-w-2{width:.125em}.svg-inline--fa.fa-w-3{width:.1875em}.svg-inline--fa.fa-w-4{width:.25em}.svg-inline--fa.fa-w-5{width:.3125em}.svg-inline--fa.fa-w-6{width:.375em}.svg-inline--fa.fa-w-7{width:.4375em}.svg-inline--fa.fa-w-8{width:.5em}.svg-inline--fa.fa-w-9{width:.5625em}.svg-inline--fa.fa-w-10{width:.625em}.svg-inline--fa.fa-w-11{width:.6875em}.svg-inline--fa.fa-w-12{width:.75em}.svg-inline--fa.fa-w-13{width:.8125em}.svg-inline--fa.fa-w-14{width:.875em}.svg-inline--fa.fa-w-15{width:.9375em}.svg-inline--fa.fa-w-16{width:1em}.svg-inline--fa.fa-w-17{width:1.0625em}.svg-inline--fa.fa-w-18{width:1.125em}.svg-inline--fa.fa-w-19{width:1.1875em}.svg-inline--fa.fa-w-20{width:1.25em}.svg-inline--fa.fa-pull-left{margin-right:.3em;width:auto}.svg-inline--fa.fa-pull-right{margin-left:.3em;width:auto}.svg-inline--fa.fa-border{height:1.5em}.svg-inline--fa.fa-li{width:2em}.svg-inline--fa.fa-fw{width:1.25em}.fa-layers svg.svg-inline--fa{bottom:0;left:0;margin:auto;position:absolute;right:0;top:0}.fa-layers{display:inline-block;height:1em;position:relative;text-align:center;vertical-align:-.125em;width:1em}.fa-layers svg.svg-inline--fa{-webkit-transform-origin:center center;transform-origin:center center}.fa-layers-counter,.fa-layers-text{display:inline-block;position:absolute;text-align:center}.fa-layers-text{left:50%;top:50%;-webkit-transform:translate(-50%,-50%);transform:translate(-50%,-50%);-webkit-transform-origin:center center;transform-origin:center center}.fa-layers-counter{background-color:#ff253a;border-radius:1em;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;right:0;text-overflow:ellipsis;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top right;transform-origin:top right}.fa-layers-bottom-right{bottom:0;right:0;top:auto;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:bottom right;transform-origin:bottom right}.fa-layers-bottom-left{bottom:0;left:0;right:auto;top:auto;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:bottom left;transform-origin:bottom left}.fa-layers-top-right{right:0;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top right;transform-origin:top right}.fa-layers-top-left{left:0;right:auto;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top left;transform-origin:top left}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:solid .08em #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s infinite linear;animation:fa-spin 2s infinite linear}.fa-pulse{-webkit-animation:fa-spin 1s infinite steps(8);animation:fa-spin 1s infinite steps(8)}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0);transform:rotate(0)}100%{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0);transform:rotate(0)}100%{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}.fa-rotate-90{-webkit-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-webkit-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-webkit-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-webkit-transform:scale(-1,1);transform:scale(-1,1)}.fa-flip-vertical{-webkit-transform:scale(1,-1);transform:scale(1,-1)}.fa-flip-horizontal.fa-flip-vertical{-webkit-transform:scale(-1,-1);transform:scale(-1,-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-180,:root .fa-rotate-270,:root .fa-rotate-90{-webkit-filter:none;filter:none}.fa-stack{display:inline-block;height:2em;position:relative;width:2em}.fa-stack-1x,.fa-stack-2x{bottom:0;left:0;margin:auto;position:absolute;right:0;top:0}.svg-inline--fa.fa-stack-1x{height:1em;width:1em}.svg-inline--fa.fa-stack-2x{height:2em;width:2em}.fa-inverse{color:#fff}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}";if("fa"!==l||h!==c){var z=new RegExp("\\.fa\\-","g"),e=new RegExp("\\."+c,"g");v=v.replace(z,"."+l+"-").replace(e,"."+h)}return v};var Qc=function(){function c(){y(this,c),this.definitions={}}return w(c,[{key:"add",value:function(){for(var c=this,l=arguments.length,h=Array(l),v=0;v1&&void 0!==arguments[1]?arguments[1]:{},h=l.transform,v=void 0===h?I:h,z=l.symbol,e=void 0!==z&&z,a=l.mask,m=void 0===a?null:a,t=l.title,s=void 0===t?null:t,r=l.classes,f=void 0===r?[]:r,M=l.attributes,i=void 0===M?{}:M,n=l.styles,H=void 0===n?{}:n;if(c){var o=c.prefix,V=c.iconName,C=c.icon;return ll(k({type:"icon"},c),function(){return cl(),O.autoA11y&&(s?i["aria-labelledby"]=O.replacementClass+"-title-"+B():i["aria-hidden"]="true"),hc({icons:{main:Zc(C),mask:m?Zc(m.icon):{found:!1,width:null,height:null,icon:{}}},prefix:o,iconName:V,transform:k({},I,v),symbol:e,title:s,extra:{attributes:i,styles:H,classes:f}})})}},function(c){var l=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},h=(c||{}).icon?c:hl(c||{}),v=l.mask;return v&&(v=(v||{}).icon?v:hl(v||{})),vl(h,k({},l,{mask:v}))}),al={noAuto:function(){var c;j({autoReplaceSvg:c=!1,observeMutations:c}),wc&&wc.disconnect()},dom:{i2svg:function(){var c=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(M){cl();var l=c.node,h=void 0===l?t:l,v=c.callback,z=void 0===v?function(){}:v;O.searchPseudoElements&&Uc(h),Kc(h,z)}},css:Jc,insertCss:function(){R(Jc())}},library:zl,parse:{transform:function(c){return xc(c)}},findIconDefinition:hl,icon:el,text:function(c){var l=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},h=l.transform,v=void 0===h?I:h,z=l.title,e=void 0===z?null:z,a=l.classes,m=void 0===a?[]:a,t=l.attributes,s=void 0===t?{}:t,r=l.styles,f=void 0===r?{}:r;return ll({type:"text",content:c},function(){return cl(),vc({content:c,transform:k({},I,v),title:e,extra:{attributes:s,styles:f,classes:[O.familyPrefix+"-layers-text"].concat(S(m))}})})},layer:function(c){return ll({type:"layer"},function(){cl();var l=[];return c(function(c){Array.isArray(c)?c.map(function(c){l=l.concat(c.abstract)}):l=l.concat(c.abstract)}),[{tag:"span",attributes:{class:O.familyPrefix+"-layers"},children:l}]})}},ml=function(){M&&O.autoReplaceSvg&&al.dom.i2svg({node:t})};Object.defineProperty(al,"config",{get:function(){return O},set:function(c){j(c)}}),function(c){try{c()}catch(c){if(!u)throw c}}(function(){f&&(m.FontAwesome||(m.FontAwesome=al),T(function(){Object.keys(E.styles).length>0&&ml(),O.observeMutations&&"function"==typeof MutationObserver&&function(c){if(s){var l=c.treeCallback,h=c.nodeCallback,v=c.pseudoElementsCallback;wc=new s(function(c){yc||D(c).forEach(function(c){if("childList"===c.type&&c.addedNodes.length>0&&!pc(c.addedNodes[0])&&(O.searchPseudoElements&&v(c.target),l(c.target)),"attributes"===c.type&&c.target.parentNode&&O.searchPseudoElements&&v(c.target.parentNode),"attributes"===c.type&&pc(c.target)&&~b.indexOf(c.attributeName))if("class"===c.attributeName){var z=Cc(X(c.target)),e=z.prefix,a=z.iconName;e&&c.target.setAttribute("data-prefix",e),a&&c.target.setAttribute("data-icon",a)}else h(c.target)})}),M&&wc.observe(t.getElementsByTagName("body")[0],{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}({treeCallback:Kc,nodeCallback:Gc,pseudoElementsCallback:Uc})})),E.hooks=k({},E.hooks,{addPack:function(c,l){E.styles[c]=k({},E.styles[c]||{},l),Hc(),ml()},addShims:function(c){var l;(l=E.shims).push.apply(l,S(c)),Hc(),ml()}})})}(); \ No newline at end of file diff --git a/seminar06-planning/simulator/vendor/three.js b/seminar06-planning/simulator/vendor/three.js new file mode 100644 index 0000000..1b795a6 --- /dev/null +++ b/seminar06-planning/simulator/vendor/three.js @@ -0,0 +1,45983 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (factory((global.THREE = {}))); +}(this, (function (exports) { 'use strict'; + + // Polyfills + + if ( Number.EPSILON === undefined ) { + + Number.EPSILON = Math.pow( 2, - 52 ); + + } + + if ( Number.isInteger === undefined ) { + + // Missing in IE + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger + + Number.isInteger = function ( value ) { + + return typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value; + + }; + + } + + // + + if ( Math.sign === undefined ) { + + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign + + Math.sign = function ( x ) { + + return ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x; + + }; + + } + + if ( 'name' in Function.prototype === false ) { + + // Missing in IE + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name + + Object.defineProperty( Function.prototype, 'name', { + + get: function () { + + return this.toString().match( /^\s*function\s*([^\(\s]*)/ )[ 1 ]; + + } + + } ); + + } + + if ( Object.assign === undefined ) { + + // Missing in IE + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign + + ( function () { + + Object.assign = function ( target ) { + + if ( target === undefined || target === null ) { + + throw new TypeError( 'Cannot convert undefined or null to object' ); + + } + + var output = Object( target ); + + for ( var index = 1; index < arguments.length; index ++ ) { + + var source = arguments[ index ]; + + if ( source !== undefined && source !== null ) { + + for ( var nextKey in source ) { + + if ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) { + + output[ nextKey ] = source[ nextKey ]; + + } + + } + + } + + } + + return output; + + }; + + } )(); + + } + + /** + * https://github.com/mrdoob/eventdispatcher.js/ + */ + + function EventDispatcher() {} + + Object.assign( EventDispatcher.prototype, { + + addEventListener: function ( type, listener ) { + + if ( this._listeners === undefined ) this._listeners = {}; + + var listeners = this._listeners; + + if ( listeners[ type ] === undefined ) { + + listeners[ type ] = []; + + } + + if ( listeners[ type ].indexOf( listener ) === - 1 ) { + + listeners[ type ].push( listener ); + + } + + }, + + hasEventListener: function ( type, listener ) { + + if ( this._listeners === undefined ) return false; + + var listeners = this._listeners; + + return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1; + + }, + + removeEventListener: function ( type, listener ) { + + if ( this._listeners === undefined ) return; + + var listeners = this._listeners; + var listenerArray = listeners[ type ]; + + if ( listenerArray !== undefined ) { + + var index = listenerArray.indexOf( listener ); + + if ( index !== - 1 ) { + + listenerArray.splice( index, 1 ); + + } + + } + + }, + + dispatchEvent: function ( event ) { + + if ( this._listeners === undefined ) return; + + var listeners = this._listeners; + var listenerArray = listeners[ event.type ]; + + if ( listenerArray !== undefined ) { + + event.target = this; + + var array = listenerArray.slice( 0 ); + + for ( var i = 0, l = array.length; i < l; i ++ ) { + + array[ i ].call( this, event ); + + } + + } + + } + + } ); + + var REVISION = '89'; + var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 }; + var CullFaceNone = 0; + var CullFaceBack = 1; + var CullFaceFront = 2; + var CullFaceFrontBack = 3; + var FrontFaceDirectionCW = 0; + var FrontFaceDirectionCCW = 1; + var BasicShadowMap = 0; + var PCFShadowMap = 1; + var PCFSoftShadowMap = 2; + var FrontSide = 0; + var BackSide = 1; + var DoubleSide = 2; + var FlatShading = 1; + var SmoothShading = 2; + var NoColors = 0; + var FaceColors = 1; + var VertexColors = 2; + var NoBlending = 0; + var NormalBlending = 1; + var AdditiveBlending = 2; + var SubtractiveBlending = 3; + var MultiplyBlending = 4; + var CustomBlending = 5; + var AddEquation = 100; + var SubtractEquation = 101; + var ReverseSubtractEquation = 102; + var MinEquation = 103; + var MaxEquation = 104; + var ZeroFactor = 200; + var OneFactor = 201; + var SrcColorFactor = 202; + var OneMinusSrcColorFactor = 203; + var SrcAlphaFactor = 204; + var OneMinusSrcAlphaFactor = 205; + var DstAlphaFactor = 206; + var OneMinusDstAlphaFactor = 207; + var DstColorFactor = 208; + var OneMinusDstColorFactor = 209; + var SrcAlphaSaturateFactor = 210; + var NeverDepth = 0; + var AlwaysDepth = 1; + var LessDepth = 2; + var LessEqualDepth = 3; + var EqualDepth = 4; + var GreaterEqualDepth = 5; + var GreaterDepth = 6; + var NotEqualDepth = 7; + var MultiplyOperation = 0; + var MixOperation = 1; + var AddOperation = 2; + var NoToneMapping = 0; + var LinearToneMapping = 1; + var ReinhardToneMapping = 2; + var Uncharted2ToneMapping = 3; + var CineonToneMapping = 4; + var UVMapping = 300; + var CubeReflectionMapping = 301; + var CubeRefractionMapping = 302; + var EquirectangularReflectionMapping = 303; + var EquirectangularRefractionMapping = 304; + var SphericalReflectionMapping = 305; + var CubeUVReflectionMapping = 306; + var CubeUVRefractionMapping = 307; + var RepeatWrapping = 1000; + var ClampToEdgeWrapping = 1001; + var MirroredRepeatWrapping = 1002; + var NearestFilter = 1003; + var NearestMipMapNearestFilter = 1004; + var NearestMipMapLinearFilter = 1005; + var LinearFilter = 1006; + var LinearMipMapNearestFilter = 1007; + var LinearMipMapLinearFilter = 1008; + var UnsignedByteType = 1009; + var ByteType = 1010; + var ShortType = 1011; + var UnsignedShortType = 1012; + var IntType = 1013; + var UnsignedIntType = 1014; + var FloatType = 1015; + var HalfFloatType = 1016; + var UnsignedShort4444Type = 1017; + var UnsignedShort5551Type = 1018; + var UnsignedShort565Type = 1019; + var UnsignedInt248Type = 1020; + var AlphaFormat = 1021; + var RGBFormat = 1022; + var RGBAFormat = 1023; + var LuminanceFormat = 1024; + var LuminanceAlphaFormat = 1025; + var RGBEFormat = RGBAFormat; + var DepthFormat = 1026; + var DepthStencilFormat = 1027; + var RGB_S3TC_DXT1_Format = 2001; + var RGBA_S3TC_DXT1_Format = 2002; + var RGBA_S3TC_DXT3_Format = 2003; + var RGBA_S3TC_DXT5_Format = 2004; + var RGB_PVRTC_4BPPV1_Format = 2100; + var RGB_PVRTC_2BPPV1_Format = 2101; + var RGBA_PVRTC_4BPPV1_Format = 2102; + var RGBA_PVRTC_2BPPV1_Format = 2103; + var RGB_ETC1_Format = 2151; + var LoopOnce = 2200; + var LoopRepeat = 2201; + var LoopPingPong = 2202; + var InterpolateDiscrete = 2300; + var InterpolateLinear = 2301; + var InterpolateSmooth = 2302; + var ZeroCurvatureEnding = 2400; + var ZeroSlopeEnding = 2401; + var WrapAroundEnding = 2402; + var TrianglesDrawMode = 0; + var TriangleStripDrawMode = 1; + var TriangleFanDrawMode = 2; + var LinearEncoding = 3000; + var sRGBEncoding = 3001; + var GammaEncoding = 3007; + var RGBEEncoding = 3002; + var LogLuvEncoding = 3003; + var RGBM7Encoding = 3004; + var RGBM16Encoding = 3005; + var RGBDEncoding = 3006; + var BasicDepthPacking = 3200; + var RGBADepthPacking = 3201; + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + */ + + var _Math = { + + DEG2RAD: Math.PI / 180, + RAD2DEG: 180 / Math.PI, + + generateUUID: ( function () { + + // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136 + + var lut = []; + + for ( var i = 0; i < 256; i ++ ) { + + lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 ).toUpperCase(); + + } + + return function () { + + var d0 = Math.random() * 0xffffffff | 0; + var d1 = Math.random() * 0xffffffff | 0; + var d2 = Math.random() * 0xffffffff | 0; + var d3 = Math.random() * 0xffffffff | 0; + return lut[ d0 & 0xff ] + lut[ d0 >> 8 & 0xff ] + lut[ d0 >> 16 & 0xff ] + lut[ d0 >> 24 & 0xff ] + '-' + + lut[ d1 & 0xff ] + lut[ d1 >> 8 & 0xff ] + '-' + lut[ d1 >> 16 & 0x0f | 0x40 ] + lut[ d1 >> 24 & 0xff ] + '-' + + lut[ d2 & 0x3f | 0x80 ] + lut[ d2 >> 8 & 0xff ] + '-' + lut[ d2 >> 16 & 0xff ] + lut[ d2 >> 24 & 0xff ] + + lut[ d3 & 0xff ] + lut[ d3 >> 8 & 0xff ] + lut[ d3 >> 16 & 0xff ] + lut[ d3 >> 24 & 0xff ]; + + }; + + } )(), + + clamp: function ( value, min, max ) { + + return Math.max( min, Math.min( max, value ) ); + + }, + + // compute euclidian modulo of m % n + // https://en.wikipedia.org/wiki/Modulo_operation + + euclideanModulo: function ( n, m ) { + + return ( ( n % m ) + m ) % m; + + }, + + // Linear mapping from range to range + + mapLinear: function ( x, a1, a2, b1, b2 ) { + + return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 ); + + }, + + // https://en.wikipedia.org/wiki/Linear_interpolation + + lerp: function ( x, y, t ) { + + return ( 1 - t ) * x + t * y; + + }, + + // http://en.wikipedia.org/wiki/Smoothstep + + smoothstep: function ( x, min, max ) { + + if ( x <= min ) return 0; + if ( x >= max ) return 1; + + x = ( x - min ) / ( max - min ); + + return x * x * ( 3 - 2 * x ); + + }, + + smootherstep: function ( x, min, max ) { + + if ( x <= min ) return 0; + if ( x >= max ) return 1; + + x = ( x - min ) / ( max - min ); + + return x * x * x * ( x * ( x * 6 - 15 ) + 10 ); + + }, + + // Random integer from interval + + randInt: function ( low, high ) { + + return low + Math.floor( Math.random() * ( high - low + 1 ) ); + + }, + + // Random float from interval + + randFloat: function ( low, high ) { + + return low + Math.random() * ( high - low ); + + }, + + // Random float from <-range/2, range/2> interval + + randFloatSpread: function ( range ) { + + return range * ( 0.5 - Math.random() ); + + }, + + degToRad: function ( degrees ) { + + return degrees * _Math.DEG2RAD; + + }, + + radToDeg: function ( radians ) { + + return radians * _Math.RAD2DEG; + + }, + + isPowerOfTwo: function ( value ) { + + return ( value & ( value - 1 ) ) === 0 && value !== 0; + + }, + + ceilPowerOfTwo: function ( value ) { + + return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) ); + + }, + + floorPowerOfTwo: function ( value ) { + + return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) ); + + } + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author philogb / http://blog.thejit.org/ + * @author egraether / http://egraether.com/ + * @author zz85 / http://www.lab4games.net/zz85/blog + */ + + function Vector2( x, y ) { + + this.x = x || 0; + this.y = y || 0; + + } + + Object.defineProperties( Vector2.prototype, { + + "width": { + + get: function () { + + return this.x; + + }, + + set: function ( value ) { + + this.x = value; + + } + + }, + + "height": { + + get: function () { + + return this.y; + + }, + + set: function ( value ) { + + this.y = value; + + } + + } + + } ); + + Object.assign( Vector2.prototype, { + + isVector2: true, + + set: function ( x, y ) { + + this.x = x; + this.y = y; + + return this; + + }, + + setScalar: function ( scalar ) { + + this.x = scalar; + this.y = scalar; + + return this; + + }, + + setX: function ( x ) { + + this.x = x; + + return this; + + }, + + setY: function ( y ) { + + this.y = y; + + return this; + + }, + + setComponent: function ( index, value ) { + + switch ( index ) { + + case 0: this.x = value; break; + case 1: this.y = value; break; + default: throw new Error( 'index is out of range: ' + index ); + + } + + return this; + + }, + + getComponent: function ( index ) { + + switch ( index ) { + + case 0: return this.x; + case 1: return this.y; + default: throw new Error( 'index is out of range: ' + index ); + + } + + }, + + clone: function () { + + return new this.constructor( this.x, this.y ); + + }, + + copy: function ( v ) { + + this.x = v.x; + this.y = v.y; + + return this; + + }, + + add: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); + return this.addVectors( v, w ); + + } + + this.x += v.x; + this.y += v.y; + + return this; + + }, + + addScalar: function ( s ) { + + this.x += s; + this.y += s; + + return this; + + }, + + addVectors: function ( a, b ) { + + this.x = a.x + b.x; + this.y = a.y + b.y; + + return this; + + }, + + addScaledVector: function ( v, s ) { + + this.x += v.x * s; + this.y += v.y * s; + + return this; + + }, + + sub: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); + return this.subVectors( v, w ); + + } + + this.x -= v.x; + this.y -= v.y; + + return this; + + }, + + subScalar: function ( s ) { + + this.x -= s; + this.y -= s; + + return this; + + }, + + subVectors: function ( a, b ) { + + this.x = a.x - b.x; + this.y = a.y - b.y; + + return this; + + }, + + multiply: function ( v ) { + + this.x *= v.x; + this.y *= v.y; + + return this; + + }, + + multiplyScalar: function ( scalar ) { + + this.x *= scalar; + this.y *= scalar; + + return this; + + }, + + divide: function ( v ) { + + this.x /= v.x; + this.y /= v.y; + + return this; + + }, + + divideScalar: function ( scalar ) { + + return this.multiplyScalar( 1 / scalar ); + + }, + + applyMatrix3: function ( m ) { + + var x = this.x, y = this.y; + var e = m.elements; + + this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ]; + this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ]; + + return this; + + }, + + min: function ( v ) { + + this.x = Math.min( this.x, v.x ); + this.y = Math.min( this.y, v.y ); + + return this; + + }, + + max: function ( v ) { + + this.x = Math.max( this.x, v.x ); + this.y = Math.max( this.y, v.y ); + + return this; + + }, + + clamp: function ( min, max ) { + + // assumes min < max, componentwise + + this.x = Math.max( min.x, Math.min( max.x, this.x ) ); + this.y = Math.max( min.y, Math.min( max.y, this.y ) ); + + return this; + + }, + + clampScalar: function () { + + var min = new Vector2(); + var max = new Vector2(); + + return function clampScalar( minVal, maxVal ) { + + min.set( minVal, minVal ); + max.set( maxVal, maxVal ); + + return this.clamp( min, max ); + + }; + + }(), + + clampLength: function ( min, max ) { + + var length = this.length(); + + return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) ); + + }, + + floor: function () { + + this.x = Math.floor( this.x ); + this.y = Math.floor( this.y ); + + return this; + + }, + + ceil: function () { + + this.x = Math.ceil( this.x ); + this.y = Math.ceil( this.y ); + + return this; + + }, + + round: function () { + + this.x = Math.round( this.x ); + this.y = Math.round( this.y ); + + return this; + + }, + + roundToZero: function () { + + this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); + this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); + + return this; + + }, + + negate: function () { + + this.x = - this.x; + this.y = - this.y; + + return this; + + }, + + dot: function ( v ) { + + return this.x * v.x + this.y * v.y; + + }, + + lengthSq: function () { + + return this.x * this.x + this.y * this.y; + + }, + + length: function () { + + return Math.sqrt( this.x * this.x + this.y * this.y ); + + }, + + manhattanLength: function () { + + return Math.abs( this.x ) + Math.abs( this.y ); + + }, + + normalize: function () { + + return this.divideScalar( this.length() || 1 ); + + }, + + angle: function () { + + // computes the angle in radians with respect to the positive x-axis + + var angle = Math.atan2( this.y, this.x ); + + if ( angle < 0 ) angle += 2 * Math.PI; + + return angle; + + }, + + distanceTo: function ( v ) { + + return Math.sqrt( this.distanceToSquared( v ) ); + + }, + + distanceToSquared: function ( v ) { + + var dx = this.x - v.x, dy = this.y - v.y; + return dx * dx + dy * dy; + + }, + + manhattanDistanceTo: function ( v ) { + + return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ); + + }, + + setLength: function ( length ) { + + return this.normalize().multiplyScalar( length ); + + }, + + lerp: function ( v, alpha ) { + + this.x += ( v.x - this.x ) * alpha; + this.y += ( v.y - this.y ) * alpha; + + return this; + + }, + + lerpVectors: function ( v1, v2, alpha ) { + + return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); + + }, + + equals: function ( v ) { + + return ( ( v.x === this.x ) && ( v.y === this.y ) ); + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + this.x = array[ offset ]; + this.y = array[ offset + 1 ]; + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this.x; + array[ offset + 1 ] = this.y; + + return array; + + }, + + fromBufferAttribute: function ( attribute, index, offset ) { + + if ( offset !== undefined ) { + + console.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' ); + + } + + this.x = attribute.getX( index ); + this.y = attribute.getY( index ); + + return this; + + }, + + rotateAround: function ( center, angle ) { + + var c = Math.cos( angle ), s = Math.sin( angle ); + + var x = this.x - center.x; + var y = this.y - center.y; + + this.x = x * c - y * s + center.x; + this.y = x * s + y * c + center.y; + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author supereggbert / http://www.paulbrunt.co.uk/ + * @author philogb / http://blog.thejit.org/ + * @author jordi_ros / http://plattsoft.com + * @author D1plo1d / http://github.com/D1plo1d + * @author alteredq / http://alteredqualia.com/ + * @author mikael emtinger / http://gomo.se/ + * @author timknip / http://www.floorplanner.com/ + * @author bhouston / http://clara.io + * @author WestLangley / http://github.com/WestLangley + */ + + function Matrix4() { + + this.elements = [ + + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1 + + ]; + + if ( arguments.length > 0 ) { + + console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' ); + + } + + } + + Object.assign( Matrix4.prototype, { + + isMatrix4: true, + + set: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) { + + var te = this.elements; + + te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14; + te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24; + te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34; + te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44; + + return this; + + }, + + identity: function () { + + this.set( + + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + clone: function () { + + return new Matrix4().fromArray( this.elements ); + + }, + + copy: function ( m ) { + + var te = this.elements; + var me = m.elements; + + te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ]; + te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; + te[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ]; + te[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ]; + + return this; + + }, + + copyPosition: function ( m ) { + + var te = this.elements, me = m.elements; + + te[ 12 ] = me[ 12 ]; + te[ 13 ] = me[ 13 ]; + te[ 14 ] = me[ 14 ]; + + return this; + + }, + + extractBasis: function ( xAxis, yAxis, zAxis ) { + + xAxis.setFromMatrixColumn( this, 0 ); + yAxis.setFromMatrixColumn( this, 1 ); + zAxis.setFromMatrixColumn( this, 2 ); + + return this; + + }, + + makeBasis: function ( xAxis, yAxis, zAxis ) { + + this.set( + xAxis.x, yAxis.x, zAxis.x, 0, + xAxis.y, yAxis.y, zAxis.y, 0, + xAxis.z, yAxis.z, zAxis.z, 0, + 0, 0, 0, 1 + ); + + return this; + + }, + + extractRotation: function () { + + var v1 = new Vector3(); + + return function extractRotation( m ) { + + var te = this.elements; + var me = m.elements; + + var scaleX = 1 / v1.setFromMatrixColumn( m, 0 ).length(); + var scaleY = 1 / v1.setFromMatrixColumn( m, 1 ).length(); + var scaleZ = 1 / v1.setFromMatrixColumn( m, 2 ).length(); + + te[ 0 ] = me[ 0 ] * scaleX; + te[ 1 ] = me[ 1 ] * scaleX; + te[ 2 ] = me[ 2 ] * scaleX; + + te[ 4 ] = me[ 4 ] * scaleY; + te[ 5 ] = me[ 5 ] * scaleY; + te[ 6 ] = me[ 6 ] * scaleY; + + te[ 8 ] = me[ 8 ] * scaleZ; + te[ 9 ] = me[ 9 ] * scaleZ; + te[ 10 ] = me[ 10 ] * scaleZ; + + return this; + + }; + + }(), + + makeRotationFromEuler: function ( euler ) { + + if ( ! ( euler && euler.isEuler ) ) { + + console.error( 'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' ); + + } + + var te = this.elements; + + var x = euler.x, y = euler.y, z = euler.z; + var a = Math.cos( x ), b = Math.sin( x ); + var c = Math.cos( y ), d = Math.sin( y ); + var e = Math.cos( z ), f = Math.sin( z ); + + if ( euler.order === 'XYZ' ) { + + var ae = a * e, af = a * f, be = b * e, bf = b * f; + + te[ 0 ] = c * e; + te[ 4 ] = - c * f; + te[ 8 ] = d; + + te[ 1 ] = af + be * d; + te[ 5 ] = ae - bf * d; + te[ 9 ] = - b * c; + + te[ 2 ] = bf - ae * d; + te[ 6 ] = be + af * d; + te[ 10 ] = a * c; + + } else if ( euler.order === 'YXZ' ) { + + var ce = c * e, cf = c * f, de = d * e, df = d * f; + + te[ 0 ] = ce + df * b; + te[ 4 ] = de * b - cf; + te[ 8 ] = a * d; + + te[ 1 ] = a * f; + te[ 5 ] = a * e; + te[ 9 ] = - b; + + te[ 2 ] = cf * b - de; + te[ 6 ] = df + ce * b; + te[ 10 ] = a * c; + + } else if ( euler.order === 'ZXY' ) { + + var ce = c * e, cf = c * f, de = d * e, df = d * f; + + te[ 0 ] = ce - df * b; + te[ 4 ] = - a * f; + te[ 8 ] = de + cf * b; + + te[ 1 ] = cf + de * b; + te[ 5 ] = a * e; + te[ 9 ] = df - ce * b; + + te[ 2 ] = - a * d; + te[ 6 ] = b; + te[ 10 ] = a * c; + + } else if ( euler.order === 'ZYX' ) { + + var ae = a * e, af = a * f, be = b * e, bf = b * f; + + te[ 0 ] = c * e; + te[ 4 ] = be * d - af; + te[ 8 ] = ae * d + bf; + + te[ 1 ] = c * f; + te[ 5 ] = bf * d + ae; + te[ 9 ] = af * d - be; + + te[ 2 ] = - d; + te[ 6 ] = b * c; + te[ 10 ] = a * c; + + } else if ( euler.order === 'YZX' ) { + + var ac = a * c, ad = a * d, bc = b * c, bd = b * d; + + te[ 0 ] = c * e; + te[ 4 ] = bd - ac * f; + te[ 8 ] = bc * f + ad; + + te[ 1 ] = f; + te[ 5 ] = a * e; + te[ 9 ] = - b * e; + + te[ 2 ] = - d * e; + te[ 6 ] = ad * f + bc; + te[ 10 ] = ac - bd * f; + + } else if ( euler.order === 'XZY' ) { + + var ac = a * c, ad = a * d, bc = b * c, bd = b * d; + + te[ 0 ] = c * e; + te[ 4 ] = - f; + te[ 8 ] = d * e; + + te[ 1 ] = ac * f + bd; + te[ 5 ] = a * e; + te[ 9 ] = ad * f - bc; + + te[ 2 ] = bc * f - ad; + te[ 6 ] = b * e; + te[ 10 ] = bd * f + ac; + + } + + // last column + te[ 3 ] = 0; + te[ 7 ] = 0; + te[ 11 ] = 0; + + // bottom row + te[ 12 ] = 0; + te[ 13 ] = 0; + te[ 14 ] = 0; + te[ 15 ] = 1; + + return this; + + }, + + makeRotationFromQuaternion: function ( q ) { + + var te = this.elements; + + var x = q._x, y = q._y, z = q._z, w = q._w; + var x2 = x + x, y2 = y + y, z2 = z + z; + var xx = x * x2, xy = x * y2, xz = x * z2; + var yy = y * y2, yz = y * z2, zz = z * z2; + var wx = w * x2, wy = w * y2, wz = w * z2; + + te[ 0 ] = 1 - ( yy + zz ); + te[ 4 ] = xy - wz; + te[ 8 ] = xz + wy; + + te[ 1 ] = xy + wz; + te[ 5 ] = 1 - ( xx + zz ); + te[ 9 ] = yz - wx; + + te[ 2 ] = xz - wy; + te[ 6 ] = yz + wx; + te[ 10 ] = 1 - ( xx + yy ); + + // last column + te[ 3 ] = 0; + te[ 7 ] = 0; + te[ 11 ] = 0; + + // bottom row + te[ 12 ] = 0; + te[ 13 ] = 0; + te[ 14 ] = 0; + te[ 15 ] = 1; + + return this; + + }, + + lookAt: function () { + + var x = new Vector3(); + var y = new Vector3(); + var z = new Vector3(); + + return function lookAt( eye, target, up ) { + + var te = this.elements; + + z.subVectors( eye, target ); + + if ( z.lengthSq() === 0 ) { + + // eye and target are in the same position + + z.z = 1; + + } + + z.normalize(); + x.crossVectors( up, z ); + + if ( x.lengthSq() === 0 ) { + + // up and z are parallel + + if ( Math.abs( up.z ) === 1 ) { + + z.x += 0.0001; + + } else { + + z.z += 0.0001; + + } + + z.normalize(); + x.crossVectors( up, z ); + + } + + x.normalize(); + y.crossVectors( z, x ); + + te[ 0 ] = x.x; te[ 4 ] = y.x; te[ 8 ] = z.x; + te[ 1 ] = x.y; te[ 5 ] = y.y; te[ 9 ] = z.y; + te[ 2 ] = x.z; te[ 6 ] = y.z; te[ 10 ] = z.z; + + return this; + + }; + + }(), + + multiply: function ( m, n ) { + + if ( n !== undefined ) { + + console.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' ); + return this.multiplyMatrices( m, n ); + + } + + return this.multiplyMatrices( this, m ); + + }, + + premultiply: function ( m ) { + + return this.multiplyMatrices( m, this ); + + }, + + multiplyMatrices: function ( a, b ) { + + var ae = a.elements; + var be = b.elements; + var te = this.elements; + + var a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ]; + var a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ]; + var a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ]; + var a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ]; + + var b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ]; + var b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ]; + var b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ]; + var b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ]; + + te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41; + te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42; + te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43; + te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44; + + te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41; + te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42; + te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43; + te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44; + + te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41; + te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42; + te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43; + te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44; + + te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41; + te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42; + te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43; + te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44; + + return this; + + }, + + multiplyScalar: function ( s ) { + + var te = this.elements; + + te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s; + te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s; + te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s; + te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s; + + return this; + + }, + + applyToBufferAttribute: function () { + + var v1 = new Vector3(); + + return function applyToBufferAttribute( attribute ) { + + for ( var i = 0, l = attribute.count; i < l; i ++ ) { + + v1.x = attribute.getX( i ); + v1.y = attribute.getY( i ); + v1.z = attribute.getZ( i ); + + v1.applyMatrix4( this ); + + attribute.setXYZ( i, v1.x, v1.y, v1.z ); + + } + + return attribute; + + }; + + }(), + + determinant: function () { + + var te = this.elements; + + var n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ]; + var n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ]; + var n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ]; + var n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ]; + + //TODO: make this more efficient + //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm ) + + return ( + n41 * ( + + n14 * n23 * n32 + - n13 * n24 * n32 + - n14 * n22 * n33 + + n12 * n24 * n33 + + n13 * n22 * n34 + - n12 * n23 * n34 + ) + + n42 * ( + + n11 * n23 * n34 + - n11 * n24 * n33 + + n14 * n21 * n33 + - n13 * n21 * n34 + + n13 * n24 * n31 + - n14 * n23 * n31 + ) + + n43 * ( + + n11 * n24 * n32 + - n11 * n22 * n34 + - n14 * n21 * n32 + + n12 * n21 * n34 + + n14 * n22 * n31 + - n12 * n24 * n31 + ) + + n44 * ( + - n13 * n22 * n31 + - n11 * n23 * n32 + + n11 * n22 * n33 + + n13 * n21 * n32 + - n12 * n21 * n33 + + n12 * n23 * n31 + ) + + ); + + }, + + transpose: function () { + + var te = this.elements; + var tmp; + + tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp; + tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp; + tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp; + + tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp; + tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp; + tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp; + + return this; + + }, + + setPosition: function ( v ) { + + var te = this.elements; + + te[ 12 ] = v.x; + te[ 13 ] = v.y; + te[ 14 ] = v.z; + + return this; + + }, + + getInverse: function ( m, throwOnDegenerate ) { + + // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm + var te = this.elements, + me = m.elements, + + n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ], + n12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ], + n13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ], + n14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ], + + t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, + t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, + t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, + t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34; + + var det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14; + + if ( det === 0 ) { + + var msg = "THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0"; + + if ( throwOnDegenerate === true ) { + + throw new Error( msg ); + + } else { + + console.warn( msg ); + + } + + return this.identity(); + + } + + var detInv = 1 / det; + + te[ 0 ] = t11 * detInv; + te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv; + te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv; + te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv; + + te[ 4 ] = t12 * detInv; + te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv; + te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv; + te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv; + + te[ 8 ] = t13 * detInv; + te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv; + te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv; + te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv; + + te[ 12 ] = t14 * detInv; + te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv; + te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv; + te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv; + + return this; + + }, + + scale: function ( v ) { + + var te = this.elements; + var x = v.x, y = v.y, z = v.z; + + te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z; + te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z; + te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z; + te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z; + + return this; + + }, + + getMaxScaleOnAxis: function () { + + var te = this.elements; + + var scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ]; + var scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ]; + var scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ]; + + return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) ); + + }, + + makeTranslation: function ( x, y, z ) { + + this.set( + + 1, 0, 0, x, + 0, 1, 0, y, + 0, 0, 1, z, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeRotationX: function ( theta ) { + + var c = Math.cos( theta ), s = Math.sin( theta ); + + this.set( + + 1, 0, 0, 0, + 0, c, - s, 0, + 0, s, c, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeRotationY: function ( theta ) { + + var c = Math.cos( theta ), s = Math.sin( theta ); + + this.set( + + c, 0, s, 0, + 0, 1, 0, 0, + - s, 0, c, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeRotationZ: function ( theta ) { + + var c = Math.cos( theta ), s = Math.sin( theta ); + + this.set( + + c, - s, 0, 0, + s, c, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeRotationAxis: function ( axis, angle ) { + + // Based on http://www.gamedev.net/reference/articles/article1199.asp + + var c = Math.cos( angle ); + var s = Math.sin( angle ); + var t = 1 - c; + var x = axis.x, y = axis.y, z = axis.z; + var tx = t * x, ty = t * y; + + this.set( + + tx * x + c, tx * y - s * z, tx * z + s * y, 0, + tx * y + s * z, ty * y + c, ty * z - s * x, 0, + tx * z - s * y, ty * z + s * x, t * z * z + c, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeScale: function ( x, y, z ) { + + this.set( + + x, 0, 0, 0, + 0, y, 0, 0, + 0, 0, z, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + makeShear: function ( x, y, z ) { + + this.set( + + 1, y, z, 0, + x, 1, z, 0, + x, y, 1, 0, + 0, 0, 0, 1 + + ); + + return this; + + }, + + compose: function ( position, quaternion, scale ) { + + this.makeRotationFromQuaternion( quaternion ); + this.scale( scale ); + this.setPosition( position ); + + return this; + + }, + + decompose: function () { + + var vector = new Vector3(); + var matrix = new Matrix4(); + + return function decompose( position, quaternion, scale ) { + + var te = this.elements; + + var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length(); + var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length(); + var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length(); + + // if determine is negative, we need to invert one scale + var det = this.determinant(); + if ( det < 0 ) sx = - sx; + + position.x = te[ 12 ]; + position.y = te[ 13 ]; + position.z = te[ 14 ]; + + // scale the rotation part + matrix.copy( this ); + + var invSX = 1 / sx; + var invSY = 1 / sy; + var invSZ = 1 / sz; + + matrix.elements[ 0 ] *= invSX; + matrix.elements[ 1 ] *= invSX; + matrix.elements[ 2 ] *= invSX; + + matrix.elements[ 4 ] *= invSY; + matrix.elements[ 5 ] *= invSY; + matrix.elements[ 6 ] *= invSY; + + matrix.elements[ 8 ] *= invSZ; + matrix.elements[ 9 ] *= invSZ; + matrix.elements[ 10 ] *= invSZ; + + quaternion.setFromRotationMatrix( matrix ); + + scale.x = sx; + scale.y = sy; + scale.z = sz; + + return this; + + }; + + }(), + + makePerspective: function ( left, right, top, bottom, near, far ) { + + if ( far === undefined ) { + + console.warn( 'THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.' ); + + } + + var te = this.elements; + var x = 2 * near / ( right - left ); + var y = 2 * near / ( top - bottom ); + + var a = ( right + left ) / ( right - left ); + var b = ( top + bottom ) / ( top - bottom ); + var c = - ( far + near ) / ( far - near ); + var d = - 2 * far * near / ( far - near ); + + te[ 0 ] = x; te[ 4 ] = 0; te[ 8 ] = a; te[ 12 ] = 0; + te[ 1 ] = 0; te[ 5 ] = y; te[ 9 ] = b; te[ 13 ] = 0; + te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = c; te[ 14 ] = d; + te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = - 1; te[ 15 ] = 0; + + return this; + + }, + + makeOrthographic: function ( left, right, top, bottom, near, far ) { + + var te = this.elements; + var w = 1.0 / ( right - left ); + var h = 1.0 / ( top - bottom ); + var p = 1.0 / ( far - near ); + + var x = ( right + left ) * w; + var y = ( top + bottom ) * h; + var z = ( far + near ) * p; + + te[ 0 ] = 2 * w; te[ 4 ] = 0; te[ 8 ] = 0; te[ 12 ] = - x; + te[ 1 ] = 0; te[ 5 ] = 2 * h; te[ 9 ] = 0; te[ 13 ] = - y; + te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = - 2 * p; te[ 14 ] = - z; + te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = 0; te[ 15 ] = 1; + + return this; + + }, + + equals: function ( matrix ) { + + var te = this.elements; + var me = matrix.elements; + + for ( var i = 0; i < 16; i ++ ) { + + if ( te[ i ] !== me[ i ] ) return false; + + } + + return true; + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + for ( var i = 0; i < 16; i ++ ) { + + this.elements[ i ] = array[ i + offset ]; + + } + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + var te = this.elements; + + array[ offset ] = te[ 0 ]; + array[ offset + 1 ] = te[ 1 ]; + array[ offset + 2 ] = te[ 2 ]; + array[ offset + 3 ] = te[ 3 ]; + + array[ offset + 4 ] = te[ 4 ]; + array[ offset + 5 ] = te[ 5 ]; + array[ offset + 6 ] = te[ 6 ]; + array[ offset + 7 ] = te[ 7 ]; + + array[ offset + 8 ] = te[ 8 ]; + array[ offset + 9 ] = te[ 9 ]; + array[ offset + 10 ] = te[ 10 ]; + array[ offset + 11 ] = te[ 11 ]; + + array[ offset + 12 ] = te[ 12 ]; + array[ offset + 13 ] = te[ 13 ]; + array[ offset + 14 ] = te[ 14 ]; + array[ offset + 15 ] = te[ 15 ]; + + return array; + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author WestLangley / http://github.com/WestLangley + * @author bhouston / http://clara.io + */ + + function Quaternion( x, y, z, w ) { + + this._x = x || 0; + this._y = y || 0; + this._z = z || 0; + this._w = ( w !== undefined ) ? w : 1; + + } + + Object.assign( Quaternion, { + + slerp: function ( qa, qb, qm, t ) { + + return qm.copy( qa ).slerp( qb, t ); + + }, + + slerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) { + + // fuzz-free, array-based Quaternion SLERP operation + + var x0 = src0[ srcOffset0 + 0 ], + y0 = src0[ srcOffset0 + 1 ], + z0 = src0[ srcOffset0 + 2 ], + w0 = src0[ srcOffset0 + 3 ], + + x1 = src1[ srcOffset1 + 0 ], + y1 = src1[ srcOffset1 + 1 ], + z1 = src1[ srcOffset1 + 2 ], + w1 = src1[ srcOffset1 + 3 ]; + + if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) { + + var s = 1 - t, + + cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, + + dir = ( cos >= 0 ? 1 : - 1 ), + sqrSin = 1 - cos * cos; + + // Skip the Slerp for tiny steps to avoid numeric problems: + if ( sqrSin > Number.EPSILON ) { + + var sin = Math.sqrt( sqrSin ), + len = Math.atan2( sin, cos * dir ); + + s = Math.sin( s * len ) / sin; + t = Math.sin( t * len ) / sin; + + } + + var tDir = t * dir; + + x0 = x0 * s + x1 * tDir; + y0 = y0 * s + y1 * tDir; + z0 = z0 * s + z1 * tDir; + w0 = w0 * s + w1 * tDir; + + // Normalize in case we just did a lerp: + if ( s === 1 - t ) { + + var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 ); + + x0 *= f; + y0 *= f; + z0 *= f; + w0 *= f; + + } + + } + + dst[ dstOffset ] = x0; + dst[ dstOffset + 1 ] = y0; + dst[ dstOffset + 2 ] = z0; + dst[ dstOffset + 3 ] = w0; + + } + + } ); + + Object.defineProperties( Quaternion.prototype, { + + x: { + + get: function () { + + return this._x; + + }, + + set: function ( value ) { + + this._x = value; + this.onChangeCallback(); + + } + + }, + + y: { + + get: function () { + + return this._y; + + }, + + set: function ( value ) { + + this._y = value; + this.onChangeCallback(); + + } + + }, + + z: { + + get: function () { + + return this._z; + + }, + + set: function ( value ) { + + this._z = value; + this.onChangeCallback(); + + } + + }, + + w: { + + get: function () { + + return this._w; + + }, + + set: function ( value ) { + + this._w = value; + this.onChangeCallback(); + + } + + } + + } ); + + Object.assign( Quaternion.prototype, { + + set: function ( x, y, z, w ) { + + this._x = x; + this._y = y; + this._z = z; + this._w = w; + + this.onChangeCallback(); + + return this; + + }, + + clone: function () { + + return new this.constructor( this._x, this._y, this._z, this._w ); + + }, + + copy: function ( quaternion ) { + + this._x = quaternion.x; + this._y = quaternion.y; + this._z = quaternion.z; + this._w = quaternion.w; + + this.onChangeCallback(); + + return this; + + }, + + setFromEuler: function ( euler, update ) { + + if ( ! ( euler && euler.isEuler ) ) { + + throw new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' ); + + } + + var x = euler._x, y = euler._y, z = euler._z, order = euler.order; + + // http://www.mathworks.com/matlabcentral/fileexchange/ + // 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/ + // content/SpinCalc.m + + var cos = Math.cos; + var sin = Math.sin; + + var c1 = cos( x / 2 ); + var c2 = cos( y / 2 ); + var c3 = cos( z / 2 ); + + var s1 = sin( x / 2 ); + var s2 = sin( y / 2 ); + var s3 = sin( z / 2 ); + + if ( order === 'XYZ' ) { + + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'YXZ' ) { + + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + + } else if ( order === 'ZXY' ) { + + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'ZYX' ) { + + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + + } else if ( order === 'YZX' ) { + + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'XZY' ) { + + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + + } + + if ( update !== false ) this.onChangeCallback(); + + return this; + + }, + + setFromAxisAngle: function ( axis, angle ) { + + // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm + + // assumes axis is normalized + + var halfAngle = angle / 2, s = Math.sin( halfAngle ); + + this._x = axis.x * s; + this._y = axis.y * s; + this._z = axis.z * s; + this._w = Math.cos( halfAngle ); + + this.onChangeCallback(); + + return this; + + }, + + setFromRotationMatrix: function ( m ) { + + // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm + + // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) + + var te = m.elements, + + m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ], + m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ], + m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ], + + trace = m11 + m22 + m33, + s; + + if ( trace > 0 ) { + + s = 0.5 / Math.sqrt( trace + 1.0 ); + + this._w = 0.25 / s; + this._x = ( m32 - m23 ) * s; + this._y = ( m13 - m31 ) * s; + this._z = ( m21 - m12 ) * s; + + } else if ( m11 > m22 && m11 > m33 ) { + + s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 ); + + this._w = ( m32 - m23 ) / s; + this._x = 0.25 * s; + this._y = ( m12 + m21 ) / s; + this._z = ( m13 + m31 ) / s; + + } else if ( m22 > m33 ) { + + s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 ); + + this._w = ( m13 - m31 ) / s; + this._x = ( m12 + m21 ) / s; + this._y = 0.25 * s; + this._z = ( m23 + m32 ) / s; + + } else { + + s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 ); + + this._w = ( m21 - m12 ) / s; + this._x = ( m13 + m31 ) / s; + this._y = ( m23 + m32 ) / s; + this._z = 0.25 * s; + + } + + this.onChangeCallback(); + + return this; + + }, + + setFromUnitVectors: function () { + + // assumes direction vectors vFrom and vTo are normalized + + var v1 = new Vector3(); + var r; + + var EPS = 0.000001; + + return function setFromUnitVectors( vFrom, vTo ) { + + if ( v1 === undefined ) v1 = new Vector3(); + + r = vFrom.dot( vTo ) + 1; + + if ( r < EPS ) { + + r = 0; + + if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) { + + v1.set( - vFrom.y, vFrom.x, 0 ); + + } else { + + v1.set( 0, - vFrom.z, vFrom.y ); + + } + + } else { + + v1.crossVectors( vFrom, vTo ); + + } + + this._x = v1.x; + this._y = v1.y; + this._z = v1.z; + this._w = r; + + return this.normalize(); + + }; + + }(), + + inverse: function () { + + return this.conjugate().normalize(); + + }, + + conjugate: function () { + + this._x *= - 1; + this._y *= - 1; + this._z *= - 1; + + this.onChangeCallback(); + + return this; + + }, + + dot: function ( v ) { + + return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w; + + }, + + lengthSq: function () { + + return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w; + + }, + + length: function () { + + return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w ); + + }, + + normalize: function () { + + var l = this.length(); + + if ( l === 0 ) { + + this._x = 0; + this._y = 0; + this._z = 0; + this._w = 1; + + } else { + + l = 1 / l; + + this._x = this._x * l; + this._y = this._y * l; + this._z = this._z * l; + this._w = this._w * l; + + } + + this.onChangeCallback(); + + return this; + + }, + + multiply: function ( q, p ) { + + if ( p !== undefined ) { + + console.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' ); + return this.multiplyQuaternions( q, p ); + + } + + return this.multiplyQuaternions( this, q ); + + }, + + premultiply: function ( q ) { + + return this.multiplyQuaternions( q, this ); + + }, + + multiplyQuaternions: function ( a, b ) { + + // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm + + var qax = a._x, qay = a._y, qaz = a._z, qaw = a._w; + var qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w; + + this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; + this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; + this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; + this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; + + this.onChangeCallback(); + + return this; + + }, + + slerp: function ( qb, t ) { + + if ( t === 0 ) return this; + if ( t === 1 ) return this.copy( qb ); + + var x = this._x, y = this._y, z = this._z, w = this._w; + + // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/ + + var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z; + + if ( cosHalfTheta < 0 ) { + + this._w = - qb._w; + this._x = - qb._x; + this._y = - qb._y; + this._z = - qb._z; + + cosHalfTheta = - cosHalfTheta; + + } else { + + this.copy( qb ); + + } + + if ( cosHalfTheta >= 1.0 ) { + + this._w = w; + this._x = x; + this._y = y; + this._z = z; + + return this; + + } + + var sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta ); + + if ( Math.abs( sinHalfTheta ) < 0.001 ) { + + this._w = 0.5 * ( w + this._w ); + this._x = 0.5 * ( x + this._x ); + this._y = 0.5 * ( y + this._y ); + this._z = 0.5 * ( z + this._z ); + + return this; + + } + + var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta ); + var ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta, + ratioB = Math.sin( t * halfTheta ) / sinHalfTheta; + + this._w = ( w * ratioA + this._w * ratioB ); + this._x = ( x * ratioA + this._x * ratioB ); + this._y = ( y * ratioA + this._y * ratioB ); + this._z = ( z * ratioA + this._z * ratioB ); + + this.onChangeCallback(); + + return this; + + }, + + equals: function ( quaternion ) { + + return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w ); + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + this._x = array[ offset ]; + this._y = array[ offset + 1 ]; + this._z = array[ offset + 2 ]; + this._w = array[ offset + 3 ]; + + this.onChangeCallback(); + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this._x; + array[ offset + 1 ] = this._y; + array[ offset + 2 ] = this._z; + array[ offset + 3 ] = this._w; + + return array; + + }, + + onChange: function ( callback ) { + + this.onChangeCallback = callback; + + return this; + + }, + + onChangeCallback: function () {} + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author kile / http://kile.stravaganza.org/ + * @author philogb / http://blog.thejit.org/ + * @author mikael emtinger / http://gomo.se/ + * @author egraether / http://egraether.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function Vector3( x, y, z ) { + + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + + } + + Object.assign( Vector3.prototype, { + + isVector3: true, + + set: function ( x, y, z ) { + + this.x = x; + this.y = y; + this.z = z; + + return this; + + }, + + setScalar: function ( scalar ) { + + this.x = scalar; + this.y = scalar; + this.z = scalar; + + return this; + + }, + + setX: function ( x ) { + + this.x = x; + + return this; + + }, + + setY: function ( y ) { + + this.y = y; + + return this; + + }, + + setZ: function ( z ) { + + this.z = z; + + return this; + + }, + + setComponent: function ( index, value ) { + + switch ( index ) { + + case 0: this.x = value; break; + case 1: this.y = value; break; + case 2: this.z = value; break; + default: throw new Error( 'index is out of range: ' + index ); + + } + + return this; + + }, + + getComponent: function ( index ) { + + switch ( index ) { + + case 0: return this.x; + case 1: return this.y; + case 2: return this.z; + default: throw new Error( 'index is out of range: ' + index ); + + } + + }, + + clone: function () { + + return new this.constructor( this.x, this.y, this.z ); + + }, + + copy: function ( v ) { + + this.x = v.x; + this.y = v.y; + this.z = v.z; + + return this; + + }, + + add: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); + return this.addVectors( v, w ); + + } + + this.x += v.x; + this.y += v.y; + this.z += v.z; + + return this; + + }, + + addScalar: function ( s ) { + + this.x += s; + this.y += s; + this.z += s; + + return this; + + }, + + addVectors: function ( a, b ) { + + this.x = a.x + b.x; + this.y = a.y + b.y; + this.z = a.z + b.z; + + return this; + + }, + + addScaledVector: function ( v, s ) { + + this.x += v.x * s; + this.y += v.y * s; + this.z += v.z * s; + + return this; + + }, + + sub: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); + return this.subVectors( v, w ); + + } + + this.x -= v.x; + this.y -= v.y; + this.z -= v.z; + + return this; + + }, + + subScalar: function ( s ) { + + this.x -= s; + this.y -= s; + this.z -= s; + + return this; + + }, + + subVectors: function ( a, b ) { + + this.x = a.x - b.x; + this.y = a.y - b.y; + this.z = a.z - b.z; + + return this; + + }, + + multiply: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' ); + return this.multiplyVectors( v, w ); + + } + + this.x *= v.x; + this.y *= v.y; + this.z *= v.z; + + return this; + + }, + + multiplyScalar: function ( scalar ) { + + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + + return this; + + }, + + multiplyVectors: function ( a, b ) { + + this.x = a.x * b.x; + this.y = a.y * b.y; + this.z = a.z * b.z; + + return this; + + }, + + applyEuler: function () { + + var quaternion = new Quaternion(); + + return function applyEuler( euler ) { + + if ( ! ( euler && euler.isEuler ) ) { + + console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' ); + + } + + return this.applyQuaternion( quaternion.setFromEuler( euler ) ); + + }; + + }(), + + applyAxisAngle: function () { + + var quaternion = new Quaternion(); + + return function applyAxisAngle( axis, angle ) { + + return this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) ); + + }; + + }(), + + applyMatrix3: function ( m ) { + + var x = this.x, y = this.y, z = this.z; + var e = m.elements; + + this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z; + this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z; + this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z; + + return this; + + }, + + applyMatrix4: function ( m ) { + + var x = this.x, y = this.y, z = this.z; + var e = m.elements; + + var w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] ); + + this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w; + this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w; + this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w; + + return this; + + }, + + applyQuaternion: function ( q ) { + + var x = this.x, y = this.y, z = this.z; + var qx = q.x, qy = q.y, qz = q.z, qw = q.w; + + // calculate quat * vector + + var ix = qw * x + qy * z - qz * y; + var iy = qw * y + qz * x - qx * z; + var iz = qw * z + qx * y - qy * x; + var iw = - qx * x - qy * y - qz * z; + + // calculate result * inverse quat + + this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy; + this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz; + this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx; + + return this; + + }, + + project: function () { + + var matrix = new Matrix4(); + + return function project( camera ) { + + matrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) ); + return this.applyMatrix4( matrix ); + + }; + + }(), + + unproject: function () { + + var matrix = new Matrix4(); + + return function unproject( camera ) { + + matrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) ); + return this.applyMatrix4( matrix ); + + }; + + }(), + + transformDirection: function ( m ) { + + // input: THREE.Matrix4 affine matrix + // vector interpreted as a direction + + var x = this.x, y = this.y, z = this.z; + var e = m.elements; + + this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z; + this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z; + this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z; + + return this.normalize(); + + }, + + divide: function ( v ) { + + this.x /= v.x; + this.y /= v.y; + this.z /= v.z; + + return this; + + }, + + divideScalar: function ( scalar ) { + + return this.multiplyScalar( 1 / scalar ); + + }, + + min: function ( v ) { + + this.x = Math.min( this.x, v.x ); + this.y = Math.min( this.y, v.y ); + this.z = Math.min( this.z, v.z ); + + return this; + + }, + + max: function ( v ) { + + this.x = Math.max( this.x, v.x ); + this.y = Math.max( this.y, v.y ); + this.z = Math.max( this.z, v.z ); + + return this; + + }, + + clamp: function ( min, max ) { + + // assumes min < max, componentwise + + this.x = Math.max( min.x, Math.min( max.x, this.x ) ); + this.y = Math.max( min.y, Math.min( max.y, this.y ) ); + this.z = Math.max( min.z, Math.min( max.z, this.z ) ); + + return this; + + }, + + clampScalar: function () { + + var min = new Vector3(); + var max = new Vector3(); + + return function clampScalar( minVal, maxVal ) { + + min.set( minVal, minVal, minVal ); + max.set( maxVal, maxVal, maxVal ); + + return this.clamp( min, max ); + + }; + + }(), + + clampLength: function ( min, max ) { + + var length = this.length(); + + return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) ); + + }, + + floor: function () { + + this.x = Math.floor( this.x ); + this.y = Math.floor( this.y ); + this.z = Math.floor( this.z ); + + return this; + + }, + + ceil: function () { + + this.x = Math.ceil( this.x ); + this.y = Math.ceil( this.y ); + this.z = Math.ceil( this.z ); + + return this; + + }, + + round: function () { + + this.x = Math.round( this.x ); + this.y = Math.round( this.y ); + this.z = Math.round( this.z ); + + return this; + + }, + + roundToZero: function () { + + this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); + this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); + this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z ); + + return this; + + }, + + negate: function () { + + this.x = - this.x; + this.y = - this.y; + this.z = - this.z; + + return this; + + }, + + dot: function ( v ) { + + return this.x * v.x + this.y * v.y + this.z * v.z; + + }, + + // TODO lengthSquared? + + lengthSq: function () { + + return this.x * this.x + this.y * this.y + this.z * this.z; + + }, + + length: function () { + + return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z ); + + }, + + manhattanLength: function () { + + return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ); + + }, + + normalize: function () { + + return this.divideScalar( this.length() || 1 ); + + }, + + setLength: function ( length ) { + + return this.normalize().multiplyScalar( length ); + + }, + + lerp: function ( v, alpha ) { + + this.x += ( v.x - this.x ) * alpha; + this.y += ( v.y - this.y ) * alpha; + this.z += ( v.z - this.z ) * alpha; + + return this; + + }, + + lerpVectors: function ( v1, v2, alpha ) { + + return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); + + }, + + cross: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' ); + return this.crossVectors( v, w ); + + } + + return this.crossVectors( this, v ); + + }, + + crossVectors: function ( a, b ) { + + var ax = a.x, ay = a.y, az = a.z; + var bx = b.x, by = b.y, bz = b.z; + + this.x = ay * bz - az * by; + this.y = az * bx - ax * bz; + this.z = ax * by - ay * bx; + + return this; + + }, + + projectOnVector: function ( vector ) { + + var scalar = vector.dot( this ) / vector.lengthSq(); + + return this.copy( vector ).multiplyScalar( scalar ); + + }, + + projectOnPlane: function () { + + var v1 = new Vector3(); + + return function projectOnPlane( planeNormal ) { + + v1.copy( this ).projectOnVector( planeNormal ); + + return this.sub( v1 ); + + }; + + }(), + + reflect: function () { + + // reflect incident vector off plane orthogonal to normal + // normal is assumed to have unit length + + var v1 = new Vector3(); + + return function reflect( normal ) { + + return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) ); + + }; + + }(), + + angleTo: function ( v ) { + + var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) ); + + // clamp, to handle numerical problems + + return Math.acos( _Math.clamp( theta, - 1, 1 ) ); + + }, + + distanceTo: function ( v ) { + + return Math.sqrt( this.distanceToSquared( v ) ); + + }, + + distanceToSquared: function ( v ) { + + var dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z; + + return dx * dx + dy * dy + dz * dz; + + }, + + manhattanDistanceTo: function ( v ) { + + return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z ); + + }, + + setFromSpherical: function ( s ) { + + var sinPhiRadius = Math.sin( s.phi ) * s.radius; + + this.x = sinPhiRadius * Math.sin( s.theta ); + this.y = Math.cos( s.phi ) * s.radius; + this.z = sinPhiRadius * Math.cos( s.theta ); + + return this; + + }, + + setFromCylindrical: function ( c ) { + + this.x = c.radius * Math.sin( c.theta ); + this.y = c.y; + this.z = c.radius * Math.cos( c.theta ); + + return this; + + }, + + setFromMatrixPosition: function ( m ) { + + var e = m.elements; + + this.x = e[ 12 ]; + this.y = e[ 13 ]; + this.z = e[ 14 ]; + + return this; + + }, + + setFromMatrixScale: function ( m ) { + + var sx = this.setFromMatrixColumn( m, 0 ).length(); + var sy = this.setFromMatrixColumn( m, 1 ).length(); + var sz = this.setFromMatrixColumn( m, 2 ).length(); + + this.x = sx; + this.y = sy; + this.z = sz; + + return this; + + }, + + setFromMatrixColumn: function ( m, index ) { + + return this.fromArray( m.elements, index * 4 ); + + }, + + equals: function ( v ) { + + return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) ); + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + this.x = array[ offset ]; + this.y = array[ offset + 1 ]; + this.z = array[ offset + 2 ]; + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this.x; + array[ offset + 1 ] = this.y; + array[ offset + 2 ] = this.z; + + return array; + + }, + + fromBufferAttribute: function ( attribute, index, offset ) { + + if ( offset !== undefined ) { + + console.warn( 'THREE.Vector3: offset has been removed from .fromBufferAttribute().' ); + + } + + this.x = attribute.getX( index ); + this.y = attribute.getY( index ); + this.z = attribute.getZ( index ); + + return this; + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author WestLangley / http://github.com/WestLangley + * @author bhouston / http://clara.io + * @author tschw + */ + + function Matrix3() { + + this.elements = [ + + 1, 0, 0, + 0, 1, 0, + 0, 0, 1 + + ]; + + if ( arguments.length > 0 ) { + + console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' ); + + } + + } + + Object.assign( Matrix3.prototype, { + + isMatrix3: true, + + set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) { + + var te = this.elements; + + te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31; + te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32; + te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33; + + return this; + + }, + + identity: function () { + + this.set( + + 1, 0, 0, + 0, 1, 0, + 0, 0, 1 + + ); + + return this; + + }, + + clone: function () { + + return new this.constructor().fromArray( this.elements ); + + }, + + copy: function ( m ) { + + var te = this.elements; + var me = m.elements; + + te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; + te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; + te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ]; + + return this; + + }, + + setFromMatrix4: function ( m ) { + + var me = m.elements; + + this.set( + + me[ 0 ], me[ 4 ], me[ 8 ], + me[ 1 ], me[ 5 ], me[ 9 ], + me[ 2 ], me[ 6 ], me[ 10 ] + + ); + + return this; + + }, + + applyToBufferAttribute: function () { + + var v1 = new Vector3(); + + return function applyToBufferAttribute( attribute ) { + + for ( var i = 0, l = attribute.count; i < l; i ++ ) { + + v1.x = attribute.getX( i ); + v1.y = attribute.getY( i ); + v1.z = attribute.getZ( i ); + + v1.applyMatrix3( this ); + + attribute.setXYZ( i, v1.x, v1.y, v1.z ); + + } + + return attribute; + + }; + + }(), + + multiply: function ( m ) { + + return this.multiplyMatrices( this, m ); + + }, + + premultiply: function ( m ) { + + return this.multiplyMatrices( m, this ); + + }, + + multiplyMatrices: function ( a, b ) { + + var ae = a.elements; + var be = b.elements; + var te = this.elements; + + var a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ]; + var a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ]; + var a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ]; + + var b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ]; + var b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ]; + var b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ]; + + te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31; + te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32; + te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33; + + te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31; + te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32; + te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33; + + te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31; + te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32; + te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33; + + return this; + + }, + + multiplyScalar: function ( s ) { + + var te = this.elements; + + te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s; + te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s; + te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s; + + return this; + + }, + + determinant: function () { + + var te = this.elements; + + var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ], + d = te[ 3 ], e = te[ 4 ], f = te[ 5 ], + g = te[ 6 ], h = te[ 7 ], i = te[ 8 ]; + + return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g; + + }, + + getInverse: function ( matrix, throwOnDegenerate ) { + + if ( matrix && matrix.isMatrix4 ) { + + console.error( "THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument." ); + + } + + var me = matrix.elements, + te = this.elements, + + n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], + n12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ], + n13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ], + + t11 = n33 * n22 - n32 * n23, + t12 = n32 * n13 - n33 * n12, + t13 = n23 * n12 - n22 * n13, + + det = n11 * t11 + n21 * t12 + n31 * t13; + + if ( det === 0 ) { + + var msg = "THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0"; + + if ( throwOnDegenerate === true ) { + + throw new Error( msg ); + + } else { + + console.warn( msg ); + + } + + return this.identity(); + + } + + var detInv = 1 / det; + + te[ 0 ] = t11 * detInv; + te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv; + te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv; + + te[ 3 ] = t12 * detInv; + te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv; + te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv; + + te[ 6 ] = t13 * detInv; + te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv; + te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv; + + return this; + + }, + + transpose: function () { + + var tmp, m = this.elements; + + tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp; + tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp; + tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp; + + return this; + + }, + + getNormalMatrix: function ( matrix4 ) { + + return this.setFromMatrix4( matrix4 ).getInverse( this ).transpose(); + + }, + + transposeIntoArray: function ( r ) { + + var m = this.elements; + + r[ 0 ] = m[ 0 ]; + r[ 1 ] = m[ 3 ]; + r[ 2 ] = m[ 6 ]; + r[ 3 ] = m[ 1 ]; + r[ 4 ] = m[ 4 ]; + r[ 5 ] = m[ 7 ]; + r[ 6 ] = m[ 2 ]; + r[ 7 ] = m[ 5 ]; + r[ 8 ] = m[ 8 ]; + + return this; + + }, + + setUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) { + + var c = Math.cos( rotation ); + var s = Math.sin( rotation ); + + this.set( + sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx, + - sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty, + 0, 0, 1 + ); + + }, + + scale: function ( sx, sy ) { + + var te = this.elements; + + te[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx; + te[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy; + + return this; + + }, + + rotate: function ( theta ) { + + var c = Math.cos( theta ); + var s = Math.sin( theta ); + + var te = this.elements; + + var a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ]; + var a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ]; + + te[ 0 ] = c * a11 + s * a21; + te[ 3 ] = c * a12 + s * a22; + te[ 6 ] = c * a13 + s * a23; + + te[ 1 ] = - s * a11 + c * a21; + te[ 4 ] = - s * a12 + c * a22; + te[ 7 ] = - s * a13 + c * a23; + + return this; + + }, + + translate: function ( tx, ty ) { + + var te = this.elements; + + te[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ]; + te[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ]; + + return this; + + }, + + equals: function ( matrix ) { + + var te = this.elements; + var me = matrix.elements; + + for ( var i = 0; i < 9; i ++ ) { + + if ( te[ i ] !== me[ i ] ) return false; + + } + + return true; + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + for ( var i = 0; i < 9; i ++ ) { + + this.elements[ i ] = array[ i + offset ]; + + } + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + var te = this.elements; + + array[ offset ] = te[ 0 ]; + array[ offset + 1 ] = te[ 1 ]; + array[ offset + 2 ] = te[ 2 ]; + + array[ offset + 3 ] = te[ 3 ]; + array[ offset + 4 ] = te[ 4 ]; + array[ offset + 5 ] = te[ 5 ]; + + array[ offset + 6 ] = te[ 6 ]; + array[ offset + 7 ] = te[ 7 ]; + array[ offset + 8 ] = te[ 8 ]; + + return array; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * @author szimek / https://github.com/szimek/ + */ + + var textureId = 0; + + function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) { + + Object.defineProperty( this, 'id', { value: textureId ++ } ); + + this.uuid = _Math.generateUUID(); + + this.name = ''; + + this.image = image !== undefined ? image : Texture.DEFAULT_IMAGE; + this.mipmaps = []; + + this.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING; + + this.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping; + this.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping; + + this.magFilter = magFilter !== undefined ? magFilter : LinearFilter; + this.minFilter = minFilter !== undefined ? minFilter : LinearMipMapLinearFilter; + + this.anisotropy = anisotropy !== undefined ? anisotropy : 1; + + this.format = format !== undefined ? format : RGBAFormat; + this.type = type !== undefined ? type : UnsignedByteType; + + this.offset = new Vector2( 0, 0 ); + this.repeat = new Vector2( 1, 1 ); + this.center = new Vector2( 0, 0 ); + this.rotation = 0; + + this.matrixAutoUpdate = true; + this.matrix = new Matrix3(); + + this.generateMipmaps = true; + this.premultiplyAlpha = false; + this.flipY = true; + this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml) + + // Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap. + // + // Also changing the encoding after already used by a Material will not automatically make the Material + // update. You need to explicitly call Material.needsUpdate to trigger it to recompile. + this.encoding = encoding !== undefined ? encoding : LinearEncoding; + + this.version = 0; + this.onUpdate = null; + + } + + Texture.DEFAULT_IMAGE = undefined; + Texture.DEFAULT_MAPPING = UVMapping; + + Texture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: Texture, + + isTexture: true, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( source ) { + + this.name = source.name; + + this.image = source.image; + this.mipmaps = source.mipmaps.slice( 0 ); + + this.mapping = source.mapping; + + this.wrapS = source.wrapS; + this.wrapT = source.wrapT; + + this.magFilter = source.magFilter; + this.minFilter = source.minFilter; + + this.anisotropy = source.anisotropy; + + this.format = source.format; + this.type = source.type; + + this.offset.copy( source.offset ); + this.repeat.copy( source.repeat ); + this.center.copy( source.center ); + this.rotation = source.rotation; + + this.matrixAutoUpdate = source.matrixAutoUpdate; + this.matrix.copy( source.matrix ); + + this.generateMipmaps = source.generateMipmaps; + this.premultiplyAlpha = source.premultiplyAlpha; + this.flipY = source.flipY; + this.unpackAlignment = source.unpackAlignment; + this.encoding = source.encoding; + + return this; + + }, + + toJSON: function ( meta ) { + + var isRootObject = ( meta === undefined || typeof meta === 'string' ); + + if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) { + + return meta.textures[ this.uuid ]; + + } + + function getDataURL( image ) { + + var canvas; + + if ( image instanceof HTMLCanvasElement ) { + + canvas = image; + + } else { + + canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ); + canvas.width = image.width; + canvas.height = image.height; + + var context = canvas.getContext( '2d' ); + + if ( image instanceof ImageData ) { + + context.putImageData( image, 0, 0 ); + + } else { + + context.drawImage( image, 0, 0, image.width, image.height ); + + } + + } + + if ( canvas.width > 2048 || canvas.height > 2048 ) { + + return canvas.toDataURL( 'image/jpeg', 0.6 ); + + } else { + + return canvas.toDataURL( 'image/png' ); + + } + + } + + var output = { + metadata: { + version: 4.5, + type: 'Texture', + generator: 'Texture.toJSON' + }, + + uuid: this.uuid, + name: this.name, + + mapping: this.mapping, + + repeat: [ this.repeat.x, this.repeat.y ], + offset: [ this.offset.x, this.offset.y ], + center: [ this.center.x, this.center.y ], + rotation: this.rotation, + + wrap: [ this.wrapS, this.wrapT ], + + minFilter: this.minFilter, + magFilter: this.magFilter, + anisotropy: this.anisotropy, + + flipY: this.flipY + }; + + if ( this.image !== undefined ) { + + // TODO: Move to THREE.Image + + var image = this.image; + + if ( image.uuid === undefined ) { + + image.uuid = _Math.generateUUID(); // UGH + + } + + if ( ! isRootObject && meta.images[ image.uuid ] === undefined ) { + + meta.images[ image.uuid ] = { + uuid: image.uuid, + url: getDataURL( image ) + }; + + } + + output.image = image.uuid; + + } + + if ( ! isRootObject ) { + + meta.textures[ this.uuid ] = output; + + } + + return output; + + }, + + dispose: function () { + + this.dispatchEvent( { type: 'dispose' } ); + + }, + + transformUv: function ( uv ) { + + if ( this.mapping !== UVMapping ) return; + + uv.applyMatrix3( this.matrix ); + + if ( uv.x < 0 || uv.x > 1 ) { + + switch ( this.wrapS ) { + + case RepeatWrapping: + + uv.x = uv.x - Math.floor( uv.x ); + break; + + case ClampToEdgeWrapping: + + uv.x = uv.x < 0 ? 0 : 1; + break; + + case MirroredRepeatWrapping: + + if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) { + + uv.x = Math.ceil( uv.x ) - uv.x; + + } else { + + uv.x = uv.x - Math.floor( uv.x ); + + } + break; + + } + + } + + if ( uv.y < 0 || uv.y > 1 ) { + + switch ( this.wrapT ) { + + case RepeatWrapping: + + uv.y = uv.y - Math.floor( uv.y ); + break; + + case ClampToEdgeWrapping: + + uv.y = uv.y < 0 ? 0 : 1; + break; + + case MirroredRepeatWrapping: + + if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) { + + uv.y = Math.ceil( uv.y ) - uv.y; + + } else { + + uv.y = uv.y - Math.floor( uv.y ); + + } + break; + + } + + } + + if ( this.flipY ) { + + uv.y = 1 - uv.y; + + } + + } + + } ); + + Object.defineProperty( Texture.prototype, "needsUpdate", { + + set: function ( value ) { + + if ( value === true ) this.version ++; + + } + + } ); + + /** + * @author supereggbert / http://www.paulbrunt.co.uk/ + * @author philogb / http://blog.thejit.org/ + * @author mikael emtinger / http://gomo.se/ + * @author egraether / http://egraether.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function Vector4( x, y, z, w ) { + + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + this.w = ( w !== undefined ) ? w : 1; + + } + + Object.assign( Vector4.prototype, { + + isVector4: true, + + set: function ( x, y, z, w ) { + + this.x = x; + this.y = y; + this.z = z; + this.w = w; + + return this; + + }, + + setScalar: function ( scalar ) { + + this.x = scalar; + this.y = scalar; + this.z = scalar; + this.w = scalar; + + return this; + + }, + + setX: function ( x ) { + + this.x = x; + + return this; + + }, + + setY: function ( y ) { + + this.y = y; + + return this; + + }, + + setZ: function ( z ) { + + this.z = z; + + return this; + + }, + + setW: function ( w ) { + + this.w = w; + + return this; + + }, + + setComponent: function ( index, value ) { + + switch ( index ) { + + case 0: this.x = value; break; + case 1: this.y = value; break; + case 2: this.z = value; break; + case 3: this.w = value; break; + default: throw new Error( 'index is out of range: ' + index ); + + } + + return this; + + }, + + getComponent: function ( index ) { + + switch ( index ) { + + case 0: return this.x; + case 1: return this.y; + case 2: return this.z; + case 3: return this.w; + default: throw new Error( 'index is out of range: ' + index ); + + } + + }, + + clone: function () { + + return new this.constructor( this.x, this.y, this.z, this.w ); + + }, + + copy: function ( v ) { + + this.x = v.x; + this.y = v.y; + this.z = v.z; + this.w = ( v.w !== undefined ) ? v.w : 1; + + return this; + + }, + + add: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); + return this.addVectors( v, w ); + + } + + this.x += v.x; + this.y += v.y; + this.z += v.z; + this.w += v.w; + + return this; + + }, + + addScalar: function ( s ) { + + this.x += s; + this.y += s; + this.z += s; + this.w += s; + + return this; + + }, + + addVectors: function ( a, b ) { + + this.x = a.x + b.x; + this.y = a.y + b.y; + this.z = a.z + b.z; + this.w = a.w + b.w; + + return this; + + }, + + addScaledVector: function ( v, s ) { + + this.x += v.x * s; + this.y += v.y * s; + this.z += v.z * s; + this.w += v.w * s; + + return this; + + }, + + sub: function ( v, w ) { + + if ( w !== undefined ) { + + console.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); + return this.subVectors( v, w ); + + } + + this.x -= v.x; + this.y -= v.y; + this.z -= v.z; + this.w -= v.w; + + return this; + + }, + + subScalar: function ( s ) { + + this.x -= s; + this.y -= s; + this.z -= s; + this.w -= s; + + return this; + + }, + + subVectors: function ( a, b ) { + + this.x = a.x - b.x; + this.y = a.y - b.y; + this.z = a.z - b.z; + this.w = a.w - b.w; + + return this; + + }, + + multiplyScalar: function ( scalar ) { + + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + this.w *= scalar; + + return this; + + }, + + applyMatrix4: function ( m ) { + + var x = this.x, y = this.y, z = this.z, w = this.w; + var e = m.elements; + + this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w; + this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w; + this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w; + this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w; + + return this; + + }, + + divideScalar: function ( scalar ) { + + return this.multiplyScalar( 1 / scalar ); + + }, + + setAxisAngleFromQuaternion: function ( q ) { + + // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm + + // q is assumed to be normalized + + this.w = 2 * Math.acos( q.w ); + + var s = Math.sqrt( 1 - q.w * q.w ); + + if ( s < 0.0001 ) { + + this.x = 1; + this.y = 0; + this.z = 0; + + } else { + + this.x = q.x / s; + this.y = q.y / s; + this.z = q.z / s; + + } + + return this; + + }, + + setAxisAngleFromRotationMatrix: function ( m ) { + + // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm + + // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) + + var angle, x, y, z, // variables for result + epsilon = 0.01, // margin to allow for rounding errors + epsilon2 = 0.1, // margin to distinguish between 0 and 180 degrees + + te = m.elements, + + m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ], + m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ], + m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ]; + + if ( ( Math.abs( m12 - m21 ) < epsilon ) && + ( Math.abs( m13 - m31 ) < epsilon ) && + ( Math.abs( m23 - m32 ) < epsilon ) ) { + + // singularity found + // first check for identity matrix which must have +1 for all terms + // in leading diagonal and zero in other terms + + if ( ( Math.abs( m12 + m21 ) < epsilon2 ) && + ( Math.abs( m13 + m31 ) < epsilon2 ) && + ( Math.abs( m23 + m32 ) < epsilon2 ) && + ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) { + + // this singularity is identity matrix so angle = 0 + + this.set( 1, 0, 0, 0 ); + + return this; // zero angle, arbitrary axis + + } + + // otherwise this singularity is angle = 180 + + angle = Math.PI; + + var xx = ( m11 + 1 ) / 2; + var yy = ( m22 + 1 ) / 2; + var zz = ( m33 + 1 ) / 2; + var xy = ( m12 + m21 ) / 4; + var xz = ( m13 + m31 ) / 4; + var yz = ( m23 + m32 ) / 4; + + if ( ( xx > yy ) && ( xx > zz ) ) { + + // m11 is the largest diagonal term + + if ( xx < epsilon ) { + + x = 0; + y = 0.707106781; + z = 0.707106781; + + } else { + + x = Math.sqrt( xx ); + y = xy / x; + z = xz / x; + + } + + } else if ( yy > zz ) { + + // m22 is the largest diagonal term + + if ( yy < epsilon ) { + + x = 0.707106781; + y = 0; + z = 0.707106781; + + } else { + + y = Math.sqrt( yy ); + x = xy / y; + z = yz / y; + + } + + } else { + + // m33 is the largest diagonal term so base result on this + + if ( zz < epsilon ) { + + x = 0.707106781; + y = 0.707106781; + z = 0; + + } else { + + z = Math.sqrt( zz ); + x = xz / z; + y = yz / z; + + } + + } + + this.set( x, y, z, angle ); + + return this; // return 180 deg rotation + + } + + // as we have reached here there are no singularities so we can handle normally + + var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) + + ( m13 - m31 ) * ( m13 - m31 ) + + ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize + + if ( Math.abs( s ) < 0.001 ) s = 1; + + // prevent divide by zero, should not happen if matrix is orthogonal and should be + // caught by singularity test above, but I've left it in just in case + + this.x = ( m32 - m23 ) / s; + this.y = ( m13 - m31 ) / s; + this.z = ( m21 - m12 ) / s; + this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 ); + + return this; + + }, + + min: function ( v ) { + + this.x = Math.min( this.x, v.x ); + this.y = Math.min( this.y, v.y ); + this.z = Math.min( this.z, v.z ); + this.w = Math.min( this.w, v.w ); + + return this; + + }, + + max: function ( v ) { + + this.x = Math.max( this.x, v.x ); + this.y = Math.max( this.y, v.y ); + this.z = Math.max( this.z, v.z ); + this.w = Math.max( this.w, v.w ); + + return this; + + }, + + clamp: function ( min, max ) { + + // assumes min < max, componentwise + + this.x = Math.max( min.x, Math.min( max.x, this.x ) ); + this.y = Math.max( min.y, Math.min( max.y, this.y ) ); + this.z = Math.max( min.z, Math.min( max.z, this.z ) ); + this.w = Math.max( min.w, Math.min( max.w, this.w ) ); + + return this; + + }, + + clampScalar: function () { + + var min, max; + + return function clampScalar( minVal, maxVal ) { + + if ( min === undefined ) { + + min = new Vector4(); + max = new Vector4(); + + } + + min.set( minVal, minVal, minVal, minVal ); + max.set( maxVal, maxVal, maxVal, maxVal ); + + return this.clamp( min, max ); + + }; + + }(), + + clampLength: function ( min, max ) { + + var length = this.length(); + + return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) ); + + }, + + floor: function () { + + this.x = Math.floor( this.x ); + this.y = Math.floor( this.y ); + this.z = Math.floor( this.z ); + this.w = Math.floor( this.w ); + + return this; + + }, + + ceil: function () { + + this.x = Math.ceil( this.x ); + this.y = Math.ceil( this.y ); + this.z = Math.ceil( this.z ); + this.w = Math.ceil( this.w ); + + return this; + + }, + + round: function () { + + this.x = Math.round( this.x ); + this.y = Math.round( this.y ); + this.z = Math.round( this.z ); + this.w = Math.round( this.w ); + + return this; + + }, + + roundToZero: function () { + + this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); + this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); + this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z ); + this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w ); + + return this; + + }, + + negate: function () { + + this.x = - this.x; + this.y = - this.y; + this.z = - this.z; + this.w = - this.w; + + return this; + + }, + + dot: function ( v ) { + + return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w; + + }, + + lengthSq: function () { + + return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w; + + }, + + length: function () { + + return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w ); + + }, + + manhattanLength: function () { + + return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w ); + + }, + + normalize: function () { + + return this.divideScalar( this.length() || 1 ); + + }, + + setLength: function ( length ) { + + return this.normalize().multiplyScalar( length ); + + }, + + lerp: function ( v, alpha ) { + + this.x += ( v.x - this.x ) * alpha; + this.y += ( v.y - this.y ) * alpha; + this.z += ( v.z - this.z ) * alpha; + this.w += ( v.w - this.w ) * alpha; + + return this; + + }, + + lerpVectors: function ( v1, v2, alpha ) { + + return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); + + }, + + equals: function ( v ) { + + return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) ); + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + this.x = array[ offset ]; + this.y = array[ offset + 1 ]; + this.z = array[ offset + 2 ]; + this.w = array[ offset + 3 ]; + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this.x; + array[ offset + 1 ] = this.y; + array[ offset + 2 ] = this.z; + array[ offset + 3 ] = this.w; + + return array; + + }, + + fromBufferAttribute: function ( attribute, index, offset ) { + + if ( offset !== undefined ) { + + console.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' ); + + } + + this.x = attribute.getX( index ); + this.y = attribute.getY( index ); + this.z = attribute.getZ( index ); + this.w = attribute.getW( index ); + + return this; + + } + + } ); + + /** + * @author szimek / https://github.com/szimek/ + * @author alteredq / http://alteredqualia.com/ + * @author Marius Kintel / https://github.com/kintel + */ + + /* + In options, we can specify: + * Texture parameters for an auto-generated target texture + * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers + */ + function WebGLRenderTarget( width, height, options ) { + + this.uuid = _Math.generateUUID(); + + this.width = width; + this.height = height; + + this.scissor = new Vector4( 0, 0, width, height ); + this.scissorTest = false; + + this.viewport = new Vector4( 0, 0, width, height ); + + options = options || {}; + + if ( options.minFilter === undefined ) options.minFilter = LinearFilter; + + this.texture = new Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding ); + + this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true; + this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true; + this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null; + + } + + WebGLRenderTarget.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: WebGLRenderTarget, + + isWebGLRenderTarget: true, + + setSize: function ( width, height ) { + + if ( this.width !== width || this.height !== height ) { + + this.width = width; + this.height = height; + + this.dispose(); + + } + + this.viewport.set( 0, 0, width, height ); + this.scissor.set( 0, 0, width, height ); + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( source ) { + + this.width = source.width; + this.height = source.height; + + this.viewport.copy( source.viewport ); + + this.texture = source.texture.clone(); + + this.depthBuffer = source.depthBuffer; + this.stencilBuffer = source.stencilBuffer; + this.depthTexture = source.depthTexture; + + return this; + + }, + + dispose: function () { + + this.dispatchEvent( { type: 'dispose' } ); + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com + */ + + function WebGLRenderTargetCube( width, height, options ) { + + WebGLRenderTarget.call( this, width, height, options ); + + this.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5 + this.activeMipMapLevel = 0; + + } + + WebGLRenderTargetCube.prototype = Object.create( WebGLRenderTarget.prototype ); + WebGLRenderTargetCube.prototype.constructor = WebGLRenderTargetCube; + + WebGLRenderTargetCube.prototype.isWebGLRenderTargetCube = true; + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function DataTexture( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) { + + Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ); + + this.image = { data: data, width: width, height: height }; + + this.magFilter = magFilter !== undefined ? magFilter : NearestFilter; + this.minFilter = minFilter !== undefined ? minFilter : NearestFilter; + + this.generateMipmaps = false; + this.flipY = false; + this.unpackAlignment = 1; + + } + + DataTexture.prototype = Object.create( Texture.prototype ); + DataTexture.prototype.constructor = DataTexture; + + DataTexture.prototype.isDataTexture = true; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) { + + images = images !== undefined ? images : []; + mapping = mapping !== undefined ? mapping : CubeReflectionMapping; + + Texture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ); + + this.flipY = false; + + } + + CubeTexture.prototype = Object.create( Texture.prototype ); + CubeTexture.prototype.constructor = CubeTexture; + + CubeTexture.prototype.isCubeTexture = true; + + Object.defineProperty( CubeTexture.prototype, 'images', { + + get: function () { + + return this.image; + + }, + + set: function ( value ) { + + this.image = value; + + } + + } ); + + /** + * @author tschw + * + * Uniforms of a program. + * Those form a tree structure with a special top-level container for the root, + * which you get by calling 'new WebGLUniforms( gl, program, renderer )'. + * + * + * Properties of inner nodes including the top-level container: + * + * .seq - array of nested uniforms + * .map - nested uniforms by name + * + * + * Methods of all nodes except the top-level container: + * + * .setValue( gl, value, [renderer] ) + * + * uploads a uniform value(s) + * the 'renderer' parameter is needed for sampler uniforms + * + * + * Static methods of the top-level container (renderer factorizations): + * + * .upload( gl, seq, values, renderer ) + * + * sets uniforms in 'seq' to 'values[id].value' + * + * .seqWithValue( seq, values ) : filteredSeq + * + * filters 'seq' entries with corresponding entry in values + * + * + * Methods of the top-level container (renderer factorizations): + * + * .setValue( gl, name, value ) + * + * sets uniform with name 'name' to 'value' + * + * .set( gl, obj, prop ) + * + * sets uniform from object and property with same name than uniform + * + * .setOptional( gl, obj, prop ) + * + * like .set for an optional property of the object + * + */ + + var emptyTexture = new Texture(); + var emptyCubeTexture = new CubeTexture(); + + // --- Base for inner nodes (including the root) --- + + function UniformContainer() { + + this.seq = []; + this.map = {}; + + } + + // --- Utilities --- + + // Array Caches (provide typed arrays for temporary by size) + + var arrayCacheF32 = []; + var arrayCacheI32 = []; + + // Float32Array caches used for uploading Matrix uniforms + + var mat4array = new Float32Array( 16 ); + var mat3array = new Float32Array( 9 ); + + // Flattening for arrays of vectors and matrices + + function flatten( array, nBlocks, blockSize ) { + + var firstElem = array[ 0 ]; + + if ( firstElem <= 0 || firstElem > 0 ) return array; + // unoptimized: ! isNaN( firstElem ) + // see http://jacksondunstan.com/articles/983 + + var n = nBlocks * blockSize, + r = arrayCacheF32[ n ]; + + if ( r === undefined ) { + + r = new Float32Array( n ); + arrayCacheF32[ n ] = r; + + } + + if ( nBlocks !== 0 ) { + + firstElem.toArray( r, 0 ); + + for ( var i = 1, offset = 0; i !== nBlocks; ++ i ) { + + offset += blockSize; + array[ i ].toArray( r, offset ); + + } + + } + + return r; + + } + + // Texture unit allocation + + function allocTexUnits( renderer, n ) { + + var r = arrayCacheI32[ n ]; + + if ( r === undefined ) { + + r = new Int32Array( n ); + arrayCacheI32[ n ] = r; + + } + + for ( var i = 0; i !== n; ++ i ) + r[ i ] = renderer.allocTextureUnit(); + + return r; + + } + + // --- Setters --- + + // Note: Defining these methods externally, because they come in a bunch + // and this way their names minify. + + // Single scalar + + function setValue1f( gl, v ) { + + gl.uniform1f( this.addr, v ); + + } + + function setValue1i( gl, v ) { + + gl.uniform1i( this.addr, v ); + + } + + // Single float vector (from flat array or THREE.VectorN) + + function setValue2fv( gl, v ) { + + if ( v.x === undefined ) { + + gl.uniform2fv( this.addr, v ); + + } else { + + gl.uniform2f( this.addr, v.x, v.y ); + + } + + } + + function setValue3fv( gl, v ) { + + if ( v.x !== undefined ) { + + gl.uniform3f( this.addr, v.x, v.y, v.z ); + + } else if ( v.r !== undefined ) { + + gl.uniform3f( this.addr, v.r, v.g, v.b ); + + } else { + + gl.uniform3fv( this.addr, v ); + + } + + } + + function setValue4fv( gl, v ) { + + if ( v.x === undefined ) { + + gl.uniform4fv( this.addr, v ); + + } else { + + gl.uniform4f( this.addr, v.x, v.y, v.z, v.w ); + + } + + } + + // Single matrix (from flat array or MatrixN) + + function setValue2fm( gl, v ) { + + gl.uniformMatrix2fv( this.addr, false, v.elements || v ); + + } + + function setValue3fm( gl, v ) { + + if ( v.elements === undefined ) { + + gl.uniformMatrix3fv( this.addr, false, v ); + + } else { + + mat3array.set( v.elements ); + gl.uniformMatrix3fv( this.addr, false, mat3array ); + + } + + } + + function setValue4fm( gl, v ) { + + if ( v.elements === undefined ) { + + gl.uniformMatrix4fv( this.addr, false, v ); + + } else { + + mat4array.set( v.elements ); + gl.uniformMatrix4fv( this.addr, false, mat4array ); + + } + + } + + // Single texture (2D / Cube) + + function setValueT1( gl, v, renderer ) { + + var unit = renderer.allocTextureUnit(); + gl.uniform1i( this.addr, unit ); + renderer.setTexture2D( v || emptyTexture, unit ); + + } + + function setValueT6( gl, v, renderer ) { + + var unit = renderer.allocTextureUnit(); + gl.uniform1i( this.addr, unit ); + renderer.setTextureCube( v || emptyCubeTexture, unit ); + + } + + // Integer / Boolean vectors or arrays thereof (always flat arrays) + + function setValue2iv( gl, v ) { + + gl.uniform2iv( this.addr, v ); + + } + + function setValue3iv( gl, v ) { + + gl.uniform3iv( this.addr, v ); + + } + + function setValue4iv( gl, v ) { + + gl.uniform4iv( this.addr, v ); + + } + + // Helper to pick the right setter for the singular case + + function getSingularSetter( type ) { + + switch ( type ) { + + case 0x1406: return setValue1f; // FLOAT + case 0x8b50: return setValue2fv; // _VEC2 + case 0x8b51: return setValue3fv; // _VEC3 + case 0x8b52: return setValue4fv; // _VEC4 + + case 0x8b5a: return setValue2fm; // _MAT2 + case 0x8b5b: return setValue3fm; // _MAT3 + case 0x8b5c: return setValue4fm; // _MAT4 + + case 0x8b5e: case 0x8d66: return setValueT1; // SAMPLER_2D, SAMPLER_EXTERNAL_OES + case 0x8b60: return setValueT6; // SAMPLER_CUBE + + case 0x1404: case 0x8b56: return setValue1i; // INT, BOOL + case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2 + case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3 + case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4 + + } + + } + + // Array of scalars + + function setValue1fv( gl, v ) { + + gl.uniform1fv( this.addr, v ); + + } + function setValue1iv( gl, v ) { + + gl.uniform1iv( this.addr, v ); + + } + + // Array of vectors (flat or from THREE classes) + + function setValueV2a( gl, v ) { + + gl.uniform2fv( this.addr, flatten( v, this.size, 2 ) ); + + } + + function setValueV3a( gl, v ) { + + gl.uniform3fv( this.addr, flatten( v, this.size, 3 ) ); + + } + + function setValueV4a( gl, v ) { + + gl.uniform4fv( this.addr, flatten( v, this.size, 4 ) ); + + } + + // Array of matrices (flat or from THREE clases) + + function setValueM2a( gl, v ) { + + gl.uniformMatrix2fv( this.addr, false, flatten( v, this.size, 4 ) ); + + } + + function setValueM3a( gl, v ) { + + gl.uniformMatrix3fv( this.addr, false, flatten( v, this.size, 9 ) ); + + } + + function setValueM4a( gl, v ) { + + gl.uniformMatrix4fv( this.addr, false, flatten( v, this.size, 16 ) ); + + } + + // Array of textures (2D / Cube) + + function setValueT1a( gl, v, renderer ) { + + var n = v.length, + units = allocTexUnits( renderer, n ); + + gl.uniform1iv( this.addr, units ); + + for ( var i = 0; i !== n; ++ i ) { + + renderer.setTexture2D( v[ i ] || emptyTexture, units[ i ] ); + + } + + } + + function setValueT6a( gl, v, renderer ) { + + var n = v.length, + units = allocTexUnits( renderer, n ); + + gl.uniform1iv( this.addr, units ); + + for ( var i = 0; i !== n; ++ i ) { + + renderer.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] ); + + } + + } + + // Helper to pick the right setter for a pure (bottom-level) array + + function getPureArraySetter( type ) { + + switch ( type ) { + + case 0x1406: return setValue1fv; // FLOAT + case 0x8b50: return setValueV2a; // _VEC2 + case 0x8b51: return setValueV3a; // _VEC3 + case 0x8b52: return setValueV4a; // _VEC4 + + case 0x8b5a: return setValueM2a; // _MAT2 + case 0x8b5b: return setValueM3a; // _MAT3 + case 0x8b5c: return setValueM4a; // _MAT4 + + case 0x8b5e: return setValueT1a; // SAMPLER_2D + case 0x8b60: return setValueT6a; // SAMPLER_CUBE + + case 0x1404: case 0x8b56: return setValue1iv; // INT, BOOL + case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2 + case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3 + case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4 + + } + + } + + // --- Uniform Classes --- + + function SingleUniform( id, activeInfo, addr ) { + + this.id = id; + this.addr = addr; + this.setValue = getSingularSetter( activeInfo.type ); + + // this.path = activeInfo.name; // DEBUG + + } + + function PureArrayUniform( id, activeInfo, addr ) { + + this.id = id; + this.addr = addr; + this.size = activeInfo.size; + this.setValue = getPureArraySetter( activeInfo.type ); + + // this.path = activeInfo.name; // DEBUG + + } + + function StructuredUniform( id ) { + + this.id = id; + + UniformContainer.call( this ); // mix-in + + } + + StructuredUniform.prototype.setValue = function ( gl, value ) { + + // Note: Don't need an extra 'renderer' parameter, since samplers + // are not allowed in structured uniforms. + + var seq = this.seq; + + for ( var i = 0, n = seq.length; i !== n; ++ i ) { + + var u = seq[ i ]; + u.setValue( gl, value[ u.id ] ); + + } + + }; + + // --- Top-level --- + + // Parser - builds up the property tree from the path strings + + var RePathPart = /([\w\d_]+)(\])?(\[|\.)?/g; + + // extracts + // - the identifier (member name or array index) + // - followed by an optional right bracket (found when array index) + // - followed by an optional left bracket or dot (type of subscript) + // + // Note: These portions can be read in a non-overlapping fashion and + // allow straightforward parsing of the hierarchy that WebGL encodes + // in the uniform names. + + function addUniform( container, uniformObject ) { + + container.seq.push( uniformObject ); + container.map[ uniformObject.id ] = uniformObject; + + } + + function parseUniform( activeInfo, addr, container ) { + + var path = activeInfo.name, + pathLength = path.length; + + // reset RegExp object, because of the early exit of a previous run + RePathPart.lastIndex = 0; + + for ( ; ; ) { + + var match = RePathPart.exec( path ), + matchEnd = RePathPart.lastIndex, + + id = match[ 1 ], + idIsIndex = match[ 2 ] === ']', + subscript = match[ 3 ]; + + if ( idIsIndex ) id = id | 0; // convert to integer + + if ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) { + + // bare name or "pure" bottom-level array "[0]" suffix + + addUniform( container, subscript === undefined ? + new SingleUniform( id, activeInfo, addr ) : + new PureArrayUniform( id, activeInfo, addr ) ); + + break; + + } else { + + // step into inner node / create it in case it doesn't exist + + var map = container.map, next = map[ id ]; + + if ( next === undefined ) { + + next = new StructuredUniform( id ); + addUniform( container, next ); + + } + + container = next; + + } + + } + + } + + // Root Container + + function WebGLUniforms( gl, program, renderer ) { + + UniformContainer.call( this ); + + this.renderer = renderer; + + var n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS ); + + for ( var i = 0; i < n; ++ i ) { + + var info = gl.getActiveUniform( program, i ), + path = info.name, + addr = gl.getUniformLocation( program, path ); + + parseUniform( info, addr, this ); + + } + + } + + WebGLUniforms.prototype.setValue = function ( gl, name, value ) { + + var u = this.map[ name ]; + + if ( u !== undefined ) u.setValue( gl, value, this.renderer ); + + }; + + WebGLUniforms.prototype.setOptional = function ( gl, object, name ) { + + var v = object[ name ]; + + if ( v !== undefined ) this.setValue( gl, name, v ); + + }; + + + // Static interface + + WebGLUniforms.upload = function ( gl, seq, values, renderer ) { + + for ( var i = 0, n = seq.length; i !== n; ++ i ) { + + var u = seq[ i ], + v = values[ u.id ]; + + if ( v.needsUpdate !== false ) { + + // note: always updating when .needsUpdate is undefined + u.setValue( gl, v.value, renderer ); + + } + + } + + }; + + WebGLUniforms.seqWithValue = function ( seq, values ) { + + var r = []; + + for ( var i = 0, n = seq.length; i !== n; ++ i ) { + + var u = seq[ i ]; + if ( u.id in values ) r.push( u ); + + } + + return r; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + var ColorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF, + 'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2, + 'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50, + 'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B, + 'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B, + 'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F, + 'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3, + 'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222, + 'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700, + 'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4, + 'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00, + 'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3, + 'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA, + 'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32, + 'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3, + 'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC, + 'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD, + 'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6, + 'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9, + 'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F, + 'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE, + 'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA, + 'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0, + 'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 }; + + function Color( r, g, b ) { + + if ( g === undefined && b === undefined ) { + + // r is THREE.Color, hex or string + return this.set( r ); + + } + + return this.setRGB( r, g, b ); + + } + + Object.assign( Color.prototype, { + + isColor: true, + + r: 1, g: 1, b: 1, + + set: function ( value ) { + + if ( value && value.isColor ) { + + this.copy( value ); + + } else if ( typeof value === 'number' ) { + + this.setHex( value ); + + } else if ( typeof value === 'string' ) { + + this.setStyle( value ); + + } + + return this; + + }, + + setScalar: function ( scalar ) { + + this.r = scalar; + this.g = scalar; + this.b = scalar; + + return this; + + }, + + setHex: function ( hex ) { + + hex = Math.floor( hex ); + + this.r = ( hex >> 16 & 255 ) / 255; + this.g = ( hex >> 8 & 255 ) / 255; + this.b = ( hex & 255 ) / 255; + + return this; + + }, + + setRGB: function ( r, g, b ) { + + this.r = r; + this.g = g; + this.b = b; + + return this; + + }, + + setHSL: function () { + + function hue2rgb( p, q, t ) { + + if ( t < 0 ) t += 1; + if ( t > 1 ) t -= 1; + if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t; + if ( t < 1 / 2 ) return q; + if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t ); + return p; + + } + + return function setHSL( h, s, l ) { + + // h,s,l ranges are in 0.0 - 1.0 + h = _Math.euclideanModulo( h, 1 ); + s = _Math.clamp( s, 0, 1 ); + l = _Math.clamp( l, 0, 1 ); + + if ( s === 0 ) { + + this.r = this.g = this.b = l; + + } else { + + var p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s ); + var q = ( 2 * l ) - p; + + this.r = hue2rgb( q, p, h + 1 / 3 ); + this.g = hue2rgb( q, p, h ); + this.b = hue2rgb( q, p, h - 1 / 3 ); + + } + + return this; + + }; + + }(), + + setStyle: function ( style ) { + + function handleAlpha( string ) { + + if ( string === undefined ) return; + + if ( parseFloat( string ) < 1 ) { + + console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' ); + + } + + } + + + var m; + + if ( m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec( style ) ) { + + // rgb / hsl + + var color; + var name = m[ 1 ]; + var components = m[ 2 ]; + + switch ( name ) { + + case 'rgb': + case 'rgba': + + if ( color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { + + // rgb(255,0,0) rgba(255,0,0,0.5) + this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255; + this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255; + this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255; + + handleAlpha( color[ 5 ] ); + + return this; + + } + + if ( color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { + + // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5) + this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100; + this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100; + this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100; + + handleAlpha( color[ 5 ] ); + + return this; + + } + + break; + + case 'hsl': + case 'hsla': + + if ( color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { + + // hsl(120,50%,50%) hsla(120,50%,50%,0.5) + var h = parseFloat( color[ 1 ] ) / 360; + var s = parseInt( color[ 2 ], 10 ) / 100; + var l = parseInt( color[ 3 ], 10 ) / 100; + + handleAlpha( color[ 5 ] ); + + return this.setHSL( h, s, l ); + + } + + break; + + } + + } else if ( m = /^\#([A-Fa-f0-9]+)$/.exec( style ) ) { + + // hex color + + var hex = m[ 1 ]; + var size = hex.length; + + if ( size === 3 ) { + + // #ff0 + this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255; + this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255; + this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255; + + return this; + + } else if ( size === 6 ) { + + // #ff0000 + this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255; + this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255; + this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255; + + return this; + + } + + } + + if ( style && style.length > 0 ) { + + // color keywords + var hex = ColorKeywords[ style ]; + + if ( hex !== undefined ) { + + // red + this.setHex( hex ); + + } else { + + // unknown color + console.warn( 'THREE.Color: Unknown color ' + style ); + + } + + } + + return this; + + }, + + clone: function () { + + return new this.constructor( this.r, this.g, this.b ); + + }, + + copy: function ( color ) { + + this.r = color.r; + this.g = color.g; + this.b = color.b; + + return this; + + }, + + copyGammaToLinear: function ( color, gammaFactor ) { + + if ( gammaFactor === undefined ) gammaFactor = 2.0; + + this.r = Math.pow( color.r, gammaFactor ); + this.g = Math.pow( color.g, gammaFactor ); + this.b = Math.pow( color.b, gammaFactor ); + + return this; + + }, + + copyLinearToGamma: function ( color, gammaFactor ) { + + if ( gammaFactor === undefined ) gammaFactor = 2.0; + + var safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0; + + this.r = Math.pow( color.r, safeInverse ); + this.g = Math.pow( color.g, safeInverse ); + this.b = Math.pow( color.b, safeInverse ); + + return this; + + }, + + convertGammaToLinear: function () { + + var r = this.r, g = this.g, b = this.b; + + this.r = r * r; + this.g = g * g; + this.b = b * b; + + return this; + + }, + + convertLinearToGamma: function () { + + this.r = Math.sqrt( this.r ); + this.g = Math.sqrt( this.g ); + this.b = Math.sqrt( this.b ); + + return this; + + }, + + getHex: function () { + + return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0; + + }, + + getHexString: function () { + + return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 ); + + }, + + getHSL: function ( optionalTarget ) { + + // h,s,l ranges are in 0.0 - 1.0 + + var hsl = optionalTarget || { h: 0, s: 0, l: 0 }; + + var r = this.r, g = this.g, b = this.b; + + var max = Math.max( r, g, b ); + var min = Math.min( r, g, b ); + + var hue, saturation; + var lightness = ( min + max ) / 2.0; + + if ( min === max ) { + + hue = 0; + saturation = 0; + + } else { + + var delta = max - min; + + saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min ); + + switch ( max ) { + + case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break; + case g: hue = ( b - r ) / delta + 2; break; + case b: hue = ( r - g ) / delta + 4; break; + + } + + hue /= 6; + + } + + hsl.h = hue; + hsl.s = saturation; + hsl.l = lightness; + + return hsl; + + }, + + getStyle: function () { + + return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')'; + + }, + + offsetHSL: function ( h, s, l ) { + + var hsl = this.getHSL(); + + hsl.h += h; hsl.s += s; hsl.l += l; + + this.setHSL( hsl.h, hsl.s, hsl.l ); + + return this; + + }, + + add: function ( color ) { + + this.r += color.r; + this.g += color.g; + this.b += color.b; + + return this; + + }, + + addColors: function ( color1, color2 ) { + + this.r = color1.r + color2.r; + this.g = color1.g + color2.g; + this.b = color1.b + color2.b; + + return this; + + }, + + addScalar: function ( s ) { + + this.r += s; + this.g += s; + this.b += s; + + return this; + + }, + + sub: function ( color ) { + + this.r = Math.max( 0, this.r - color.r ); + this.g = Math.max( 0, this.g - color.g ); + this.b = Math.max( 0, this.b - color.b ); + + return this; + + }, + + multiply: function ( color ) { + + this.r *= color.r; + this.g *= color.g; + this.b *= color.b; + + return this; + + }, + + multiplyScalar: function ( s ) { + + this.r *= s; + this.g *= s; + this.b *= s; + + return this; + + }, + + lerp: function ( color, alpha ) { + + this.r += ( color.r - this.r ) * alpha; + this.g += ( color.g - this.g ) * alpha; + this.b += ( color.b - this.b ) * alpha; + + return this; + + }, + + equals: function ( c ) { + + return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b ); + + }, + + fromArray: function ( array, offset ) { + + if ( offset === undefined ) offset = 0; + + this.r = array[ offset ]; + this.g = array[ offset + 1 ]; + this.b = array[ offset + 2 ]; + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this.r; + array[ offset + 1 ] = this.g; + array[ offset + 2 ] = this.b; + + return array; + + }, + + toJSON: function () { + + return this.getHex(); + + } + + } ); + + /** + * Uniforms library for shared webgl shaders + */ + + var UniformsLib = { + + common: { + + diffuse: { value: new Color( 0xeeeeee ) }, + opacity: { value: 1.0 }, + + map: { value: null }, + uvTransform: { value: new Matrix3() }, + + alphaMap: { value: null }, + + }, + + specularmap: { + + specularMap: { value: null }, + + }, + + envmap: { + + envMap: { value: null }, + flipEnvMap: { value: - 1 }, + reflectivity: { value: 1.0 }, + refractionRatio: { value: 0.98 } + + }, + + aomap: { + + aoMap: { value: null }, + aoMapIntensity: { value: 1 } + + }, + + lightmap: { + + lightMap: { value: null }, + lightMapIntensity: { value: 1 } + + }, + + emissivemap: { + + emissiveMap: { value: null } + + }, + + bumpmap: { + + bumpMap: { value: null }, + bumpScale: { value: 1 } + + }, + + normalmap: { + + normalMap: { value: null }, + normalScale: { value: new Vector2( 1, 1 ) } + + }, + + displacementmap: { + + displacementMap: { value: null }, + displacementScale: { value: 1 }, + displacementBias: { value: 0 } + + }, + + roughnessmap: { + + roughnessMap: { value: null } + + }, + + metalnessmap: { + + metalnessMap: { value: null } + + }, + + gradientmap: { + + gradientMap: { value: null } + + }, + + fog: { + + fogDensity: { value: 0.00025 }, + fogNear: { value: 1 }, + fogFar: { value: 2000 }, + fogColor: { value: new Color( 0xffffff ) } + + }, + + lights: { + + ambientLightColor: { value: [] }, + + directionalLights: { value: [], properties: { + direction: {}, + color: {}, + + shadow: {}, + shadowBias: {}, + shadowRadius: {}, + shadowMapSize: {} + } }, + + directionalShadowMap: { value: [] }, + directionalShadowMatrix: { value: [] }, + + spotLights: { value: [], properties: { + color: {}, + position: {}, + direction: {}, + distance: {}, + coneCos: {}, + penumbraCos: {}, + decay: {}, + + shadow: {}, + shadowBias: {}, + shadowRadius: {}, + shadowMapSize: {} + } }, + + spotShadowMap: { value: [] }, + spotShadowMatrix: { value: [] }, + + pointLights: { value: [], properties: { + color: {}, + position: {}, + decay: {}, + distance: {}, + + shadow: {}, + shadowBias: {}, + shadowRadius: {}, + shadowMapSize: {}, + shadowCameraNear: {}, + shadowCameraFar: {} + } }, + + pointShadowMap: { value: [] }, + pointShadowMatrix: { value: [] }, + + hemisphereLights: { value: [], properties: { + direction: {}, + skyColor: {}, + groundColor: {} + } }, + + // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src + rectAreaLights: { value: [], properties: { + color: {}, + position: {}, + width: {}, + height: {} + } } + + }, + + points: { + + diffuse: { value: new Color( 0xeeeeee ) }, + opacity: { value: 1.0 }, + size: { value: 1.0 }, + scale: { value: 1.0 }, + map: { value: null }, + uvTransform: { value: new Matrix3() } + + } + + }; + + /** + * Uniform Utilities + */ + + var UniformsUtils = { + + merge: function ( uniforms ) { + + var merged = {}; + + for ( var u = 0; u < uniforms.length; u ++ ) { + + var tmp = this.clone( uniforms[ u ] ); + + for ( var p in tmp ) { + + merged[ p ] = tmp[ p ]; + + } + + } + + return merged; + + }, + + clone: function ( uniforms_src ) { + + var uniforms_dst = {}; + + for ( var u in uniforms_src ) { + + uniforms_dst[ u ] = {}; + + for ( var p in uniforms_src[ u ] ) { + + var parameter_src = uniforms_src[ u ][ p ]; + + if ( parameter_src && ( parameter_src.isColor || + parameter_src.isMatrix3 || parameter_src.isMatrix4 || + parameter_src.isVector2 || parameter_src.isVector3 || parameter_src.isVector4 || + parameter_src.isTexture ) ) { + + uniforms_dst[ u ][ p ] = parameter_src.clone(); + + } else if ( Array.isArray( parameter_src ) ) { + + uniforms_dst[ u ][ p ] = parameter_src.slice(); + + } else { + + uniforms_dst[ u ][ p ] = parameter_src; + + } + + } + + } + + return uniforms_dst; + + } + + }; + + var alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n"; + + var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif\n"; + + var alphatest_fragment = "#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n"; + + var 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"; + + var aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif"; + + var begin_vertex = "\nvec3 transformed = vec3( position );\n"; + + var beginnormal_vertex = "\nvec3 objectNormal = vec3( normal );\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvarying vec3 vViewPosition;\n#endif\n"; + + var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n"; + + var color_fragment = "#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif"; + + var color_pars_fragment = "#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif\n"; + + var color_pars_vertex = "#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif"; + + var color_vertex = "#ifdef USE_COLOR\n\tvColor.xyz = color.xyz;\n#endif"; + + var 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"; + + var 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"; + + var defaultnormal_vertex = "vec3 transformedNormal = normalMatrix * objectNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n"; + + var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif\n"; + + var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n"; + + var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif\n"; + + var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif\n"; + + var encodings_fragment = " gl_FragColor = linearToOutputTexel( gl_FragColor );\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var fog_vertex = "\n#ifdef USE_FOG\nfogDepth = -mvPosition.z;\n#endif"; + + var fog_pars_vertex = "#ifdef USE_FOG\n varying float fogDepth;\n#endif\n"; + + var 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"; + + var 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"; + + var 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"; + + var lightmap_fragment = "#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n"; + + var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif"; + + var 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"; + + var 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"; + + var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif"; + + var 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"; + + var 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"; + + var 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"; + + var map_fragment = "#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif\n"; + + var map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n"; + + var 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"; + + var map_particle_pars_fragment = "#ifdef USE_MAP\n\tuniform mat3 uvTransform;\n\tuniform sampler2D map;\n#endif\n"; + + var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif\n"; + + var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif\n"; + + var project_vertex = "vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\ngl_Position = projectionMatrix * mvPosition;\n"; + + var dithering_fragment = "#if defined( DITHERING )\n gl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif\n"; + + var 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"; + + var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif\n"; + + var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif"; + + var tonemapping_fragment = "#if defined( TONE_MAPPING )\n gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var uv2_pars_fragment = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif"; + + var uv2_pars_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n#endif"; + + var uv2_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = uv2;\n#endif"; + + var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n#endif\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var equirect_vert = "varying vec3 vWorldPosition;\n#include \nvoid main() {\n\tvWorldPosition = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n}\n"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var 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"; + + var shadow_vert = "#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}\n"; + + var ShaderChunk = { + alphamap_fragment: alphamap_fragment, + alphamap_pars_fragment: alphamap_pars_fragment, + alphatest_fragment: alphatest_fragment, + aomap_fragment: aomap_fragment, + aomap_pars_fragment: aomap_pars_fragment, + begin_vertex: begin_vertex, + beginnormal_vertex: beginnormal_vertex, + bsdfs: bsdfs, + bumpmap_pars_fragment: bumpmap_pars_fragment, + clipping_planes_fragment: clipping_planes_fragment, + clipping_planes_pars_fragment: clipping_planes_pars_fragment, + clipping_planes_pars_vertex: clipping_planes_pars_vertex, + clipping_planes_vertex: clipping_planes_vertex, + color_fragment: color_fragment, + color_pars_fragment: color_pars_fragment, + color_pars_vertex: color_pars_vertex, + color_vertex: color_vertex, + common: common, + cube_uv_reflection_fragment: cube_uv_reflection_fragment, + defaultnormal_vertex: defaultnormal_vertex, + displacementmap_pars_vertex: displacementmap_pars_vertex, + displacementmap_vertex: displacementmap_vertex, + emissivemap_fragment: emissivemap_fragment, + emissivemap_pars_fragment: emissivemap_pars_fragment, + encodings_fragment: encodings_fragment, + encodings_pars_fragment: encodings_pars_fragment, + envmap_fragment: envmap_fragment, + envmap_pars_fragment: envmap_pars_fragment, + envmap_pars_vertex: envmap_pars_vertex, + envmap_vertex: envmap_vertex, + fog_vertex: fog_vertex, + fog_pars_vertex: fog_pars_vertex, + fog_fragment: fog_fragment, + fog_pars_fragment: fog_pars_fragment, + gradientmap_pars_fragment: gradientmap_pars_fragment, + lightmap_fragment: lightmap_fragment, + lightmap_pars_fragment: lightmap_pars_fragment, + lights_lambert_vertex: lights_lambert_vertex, + lights_pars: lights_pars, + lights_phong_fragment: lights_phong_fragment, + lights_phong_pars_fragment: lights_phong_pars_fragment, + lights_physical_fragment: lights_physical_fragment, + lights_physical_pars_fragment: lights_physical_pars_fragment, + lights_template: lights_template, + logdepthbuf_fragment: logdepthbuf_fragment, + logdepthbuf_pars_fragment: logdepthbuf_pars_fragment, + logdepthbuf_pars_vertex: logdepthbuf_pars_vertex, + logdepthbuf_vertex: logdepthbuf_vertex, + map_fragment: map_fragment, + map_pars_fragment: map_pars_fragment, + map_particle_fragment: map_particle_fragment, + map_particle_pars_fragment: map_particle_pars_fragment, + metalnessmap_fragment: metalnessmap_fragment, + metalnessmap_pars_fragment: metalnessmap_pars_fragment, + morphnormal_vertex: morphnormal_vertex, + morphtarget_pars_vertex: morphtarget_pars_vertex, + morphtarget_vertex: morphtarget_vertex, + normal_fragment: normal_fragment, + normalmap_pars_fragment: normalmap_pars_fragment, + packing: packing, + premultiplied_alpha_fragment: premultiplied_alpha_fragment, + project_vertex: project_vertex, + dithering_fragment: dithering_fragment, + dithering_pars_fragment: dithering_pars_fragment, + roughnessmap_fragment: roughnessmap_fragment, + roughnessmap_pars_fragment: roughnessmap_pars_fragment, + shadowmap_pars_fragment: shadowmap_pars_fragment, + shadowmap_pars_vertex: shadowmap_pars_vertex, + shadowmap_vertex: shadowmap_vertex, + shadowmask_pars_fragment: shadowmask_pars_fragment, + skinbase_vertex: skinbase_vertex, + skinning_pars_vertex: skinning_pars_vertex, + skinning_vertex: skinning_vertex, + skinnormal_vertex: skinnormal_vertex, + specularmap_fragment: specularmap_fragment, + specularmap_pars_fragment: specularmap_pars_fragment, + tonemapping_fragment: tonemapping_fragment, + tonemapping_pars_fragment: tonemapping_pars_fragment, + uv_pars_fragment: uv_pars_fragment, + uv_pars_vertex: uv_pars_vertex, + uv_vertex: uv_vertex, + uv2_pars_fragment: uv2_pars_fragment, + uv2_pars_vertex: uv2_pars_vertex, + uv2_vertex: uv2_vertex, + worldpos_vertex: worldpos_vertex, + + cube_frag: cube_frag, + cube_vert: cube_vert, + depth_frag: depth_frag, + depth_vert: depth_vert, + distanceRGBA_frag: distanceRGBA_frag, + distanceRGBA_vert: distanceRGBA_vert, + equirect_frag: equirect_frag, + equirect_vert: equirect_vert, + linedashed_frag: linedashed_frag, + linedashed_vert: linedashed_vert, + meshbasic_frag: meshbasic_frag, + meshbasic_vert: meshbasic_vert, + meshlambert_frag: meshlambert_frag, + meshlambert_vert: meshlambert_vert, + meshphong_frag: meshphong_frag, + meshphong_vert: meshphong_vert, + meshphysical_frag: meshphysical_frag, + meshphysical_vert: meshphysical_vert, + normal_frag: normal_frag, + normal_vert: normal_vert, + points_frag: points_frag, + points_vert: points_vert, + shadow_frag: shadow_frag, + shadow_vert: shadow_vert + }; + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + * @author mikael emtinger / http://gomo.se/ + */ + + var ShaderLib = { + + basic: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.fog + ] ), + + vertexShader: ShaderChunk.meshbasic_vert, + fragmentShader: ShaderChunk.meshbasic_frag + + }, + + lambert: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: new Color( 0x000000 ) } + } + ] ), + + vertexShader: ShaderChunk.meshlambert_vert, + fragmentShader: ShaderChunk.meshlambert_frag + + }, + + phong: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.gradientmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: new Color( 0x000000 ) }, + specular: { value: new Color( 0x111111 ) }, + shininess: { value: 30 } + } + ] ), + + vertexShader: ShaderChunk.meshphong_vert, + fragmentShader: ShaderChunk.meshphong_frag + + }, + + standard: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.roughnessmap, + UniformsLib.metalnessmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: new Color( 0x000000 ) }, + roughness: { value: 0.5 }, + metalness: { value: 0.5 }, + envMapIntensity: { value: 1 } // temporary + } + ] ), + + vertexShader: ShaderChunk.meshphysical_vert, + fragmentShader: ShaderChunk.meshphysical_frag + + }, + + points: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.points, + UniformsLib.fog + ] ), + + vertexShader: ShaderChunk.points_vert, + fragmentShader: ShaderChunk.points_frag + + }, + + dashed: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.fog, + { + scale: { value: 1 }, + dashSize: { value: 1 }, + totalSize: { value: 2 } + } + ] ), + + vertexShader: ShaderChunk.linedashed_vert, + fragmentShader: ShaderChunk.linedashed_frag + + }, + + depth: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.displacementmap + ] ), + + vertexShader: ShaderChunk.depth_vert, + fragmentShader: ShaderChunk.depth_frag + + }, + + normal: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + { + opacity: { value: 1.0 } + } + ] ), + + vertexShader: ShaderChunk.normal_vert, + fragmentShader: ShaderChunk.normal_frag + + }, + + /* ------------------------------------------------------------------------- + // Cube map shader + ------------------------------------------------------------------------- */ + + cube: { + + uniforms: { + tCube: { value: null }, + tFlip: { value: - 1 }, + opacity: { value: 1.0 } + }, + + vertexShader: ShaderChunk.cube_vert, + fragmentShader: ShaderChunk.cube_frag + + }, + + equirect: { + + uniforms: { + tEquirect: { value: null }, + }, + + vertexShader: ShaderChunk.equirect_vert, + fragmentShader: ShaderChunk.equirect_frag + + }, + + distanceRGBA: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.common, + UniformsLib.displacementmap, + { + referencePosition: { value: new Vector3() }, + nearDistance: { value: 1 }, + farDistance: { value: 1000 } + } + ] ), + + vertexShader: ShaderChunk.distanceRGBA_vert, + fragmentShader: ShaderChunk.distanceRGBA_frag + + }, + + shadow: { + + uniforms: UniformsUtils.merge( [ + UniformsLib.lights, + UniformsLib.fog, + { + color: { value: new Color( 0x00000 ) }, + opacity: { value: 1.0 } + }, + ] ), + + vertexShader: ShaderChunk.shadow_vert, + fragmentShader: ShaderChunk.shadow_frag + + } + + }; + + ShaderLib.physical = { + + uniforms: UniformsUtils.merge( [ + ShaderLib.standard.uniforms, + { + clearCoat: { value: 0 }, + clearCoatRoughness: { value: 0 } + } + ] ), + + vertexShader: ShaderChunk.meshphysical_vert, + fragmentShader: ShaderChunk.meshphysical_frag + + }; + + /** + * @author bhouston / http://clara.io + */ + + function Box2( min, max ) { + + this.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity ); + this.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity ); + + } + + Object.assign( Box2.prototype, { + + set: function ( min, max ) { + + this.min.copy( min ); + this.max.copy( max ); + + return this; + + }, + + setFromPoints: function ( points ) { + + this.makeEmpty(); + + for ( var i = 0, il = points.length; i < il; i ++ ) { + + this.expandByPoint( points[ i ] ); + + } + + return this; + + }, + + setFromCenterAndSize: function () { + + var v1 = new Vector2(); + + return function setFromCenterAndSize( center, size ) { + + var halfSize = v1.copy( size ).multiplyScalar( 0.5 ); + this.min.copy( center ).sub( halfSize ); + this.max.copy( center ).add( halfSize ); + + return this; + + }; + + }(), + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( box ) { + + this.min.copy( box.min ); + this.max.copy( box.max ); + + return this; + + }, + + makeEmpty: function () { + + this.min.x = this.min.y = + Infinity; + this.max.x = this.max.y = - Infinity; + + return this; + + }, + + isEmpty: function () { + + // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes + + return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ); + + }, + + getCenter: function ( optionalTarget ) { + + var result = optionalTarget || new Vector2(); + return this.isEmpty() ? result.set( 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 ); + + }, + + getSize: function ( optionalTarget ) { + + var result = optionalTarget || new Vector2(); + return this.isEmpty() ? result.set( 0, 0 ) : result.subVectors( this.max, this.min ); + + }, + + expandByPoint: function ( point ) { + + this.min.min( point ); + this.max.max( point ); + + return this; + + }, + + expandByVector: function ( vector ) { + + this.min.sub( vector ); + this.max.add( vector ); + + return this; + + }, + + expandByScalar: function ( scalar ) { + + this.min.addScalar( - scalar ); + this.max.addScalar( scalar ); + + return this; + + }, + + containsPoint: function ( point ) { + + return point.x < this.min.x || point.x > this.max.x || + point.y < this.min.y || point.y > this.max.y ? false : true; + + }, + + containsBox: function ( box ) { + + return this.min.x <= box.min.x && box.max.x <= this.max.x && + this.min.y <= box.min.y && box.max.y <= this.max.y; + + }, + + getParameter: function ( point, optionalTarget ) { + + // This can potentially have a divide by zero if the box + // has a size dimension of 0. + + var result = optionalTarget || new Vector2(); + + return result.set( + ( point.x - this.min.x ) / ( this.max.x - this.min.x ), + ( point.y - this.min.y ) / ( this.max.y - this.min.y ) + ); + + }, + + intersectsBox: function ( box ) { + + // using 4 splitting planes to rule out intersections + + return box.max.x < this.min.x || box.min.x > this.max.x || + box.max.y < this.min.y || box.min.y > this.max.y ? false : true; + + }, + + clampPoint: function ( point, optionalTarget ) { + + var result = optionalTarget || new Vector2(); + return result.copy( point ).clamp( this.min, this.max ); + + }, + + distanceToPoint: function () { + + var v1 = new Vector2(); + + return function distanceToPoint( point ) { + + var clampedPoint = v1.copy( point ).clamp( this.min, this.max ); + return clampedPoint.sub( point ).length(); + + }; + + }(), + + intersect: function ( box ) { + + this.min.max( box.min ); + this.max.min( box.max ); + + return this; + + }, + + union: function ( box ) { + + this.min.min( box.min ); + this.max.max( box.max ); + + return this; + + }, + + translate: function ( offset ) { + + this.min.add( offset ); + this.max.add( offset ); + + return this; + + }, + + equals: function ( box ) { + + return box.min.equals( this.min ) && box.max.equals( this.max ); + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + */ + + function WebGLFlareRenderer( renderer, gl, state, textures, capabilities ) { + + var vertexBuffer, elementBuffer; + var shader, program, attributes, uniforms; + + var tempTexture, occlusionTexture; + + function init() { + + var vertices = new Float32Array( [ + - 1, - 1, 0, 0, + 1, - 1, 1, 0, + 1, 1, 1, 1, + - 1, 1, 0, 1 + ] ); + + var faces = new Uint16Array( [ + 0, 1, 2, + 0, 2, 3 + ] ); + + // buffers + + vertexBuffer = gl.createBuffer(); + elementBuffer = gl.createBuffer(); + + gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); + gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); + + gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); + gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW ); + + // textures + + tempTexture = gl.createTexture(); + occlusionTexture = gl.createTexture(); + + state.bindTexture( gl.TEXTURE_2D, tempTexture ); + gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST ); + + state.bindTexture( gl.TEXTURE_2D, occlusionTexture ); + gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST ); + gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST ); + + shader = { + + vertexShader: [ + + 'uniform lowp int renderType;', + + 'uniform vec3 screenPosition;', + 'uniform vec2 scale;', + 'uniform float rotation;', + + 'uniform sampler2D occlusionMap;', + + 'attribute vec2 position;', + 'attribute vec2 uv;', + + 'varying vec2 vUV;', + 'varying float vVisibility;', + + 'void main() {', + + ' vUV = uv;', + + ' vec2 pos = position;', + + ' if ( renderType == 2 ) {', + + ' vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );', + ' visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );', + + ' vVisibility = visibility.r / 9.0;', + ' vVisibility *= 1.0 - visibility.g / 9.0;', + ' vVisibility *= visibility.b / 9.0;', + ' vVisibility *= 1.0 - visibility.a / 9.0;', + + ' pos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;', + ' pos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;', + + ' }', + + ' gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );', + + '}' + + ].join( '\n' ), + + fragmentShader: [ + + 'uniform lowp int renderType;', + + 'uniform sampler2D map;', + 'uniform float opacity;', + 'uniform vec3 color;', + + 'varying vec2 vUV;', + 'varying float vVisibility;', + + 'void main() {', + + // pink square + + ' if ( renderType == 0 ) {', + + ' gl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );', + + // restore + + ' } else if ( renderType == 1 ) {', + + ' gl_FragColor = texture2D( map, vUV );', + + // flare + + ' } else {', + + ' vec4 texture = texture2D( map, vUV );', + ' texture.a *= opacity * vVisibility;', + ' gl_FragColor = texture;', + ' gl_FragColor.rgb *= color;', + + ' }', + + '}' + + ].join( '\n' ) + + }; + + program = createProgram( shader ); + + attributes = { + vertex: gl.getAttribLocation( program, 'position' ), + uv: gl.getAttribLocation( program, 'uv' ) + }; + + uniforms = { + renderType: gl.getUniformLocation( program, 'renderType' ), + map: gl.getUniformLocation( program, 'map' ), + occlusionMap: gl.getUniformLocation( program, 'occlusionMap' ), + opacity: gl.getUniformLocation( program, 'opacity' ), + color: gl.getUniformLocation( program, 'color' ), + scale: gl.getUniformLocation( program, 'scale' ), + rotation: gl.getUniformLocation( program, 'rotation' ), + screenPosition: gl.getUniformLocation( program, 'screenPosition' ) + }; + + } + + /* + * Render lens flares + * Method: renders 16x16 0xff00ff-colored points scattered over the light source area, + * reads these back and calculates occlusion. + */ + + this.render = function ( flares, scene, camera, viewport ) { + + if ( flares.length === 0 ) return; + + var tempPosition = new Vector3(); + + var invAspect = viewport.w / viewport.z, + halfViewportWidth = viewport.z * 0.5, + halfViewportHeight = viewport.w * 0.5; + + var size = 16 / viewport.w, + scale = new Vector2( size * invAspect, size ); + + var screenPosition = new Vector3( 1, 1, 0 ), + screenPositionPixels = new Vector2( 1, 1 ); + + var validArea = new Box2(); + + validArea.min.set( viewport.x, viewport.y ); + validArea.max.set( viewport.x + ( viewport.z - 16 ), viewport.y + ( viewport.w - 16 ) ); + + if ( program === undefined ) { + + init(); + + } + + state.useProgram( program ); + + state.initAttributes(); + state.enableAttribute( attributes.vertex ); + state.enableAttribute( attributes.uv ); + state.disableUnusedAttributes(); + + // loop through all lens flares to update their occlusion and positions + // setup gl and common used attribs/uniforms + + gl.uniform1i( uniforms.occlusionMap, 0 ); + gl.uniform1i( uniforms.map, 1 ); + + gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); + gl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 ); + gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 ); + + gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); + + state.disable( gl.CULL_FACE ); + state.buffers.depth.setMask( false ); + + for ( var i = 0, l = flares.length; i < l; i ++ ) { + + size = 16 / viewport.w; + scale.set( size * invAspect, size ); + + // calc object screen position + + var flare = flares[ i ]; + + tempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] ); + + tempPosition.applyMatrix4( camera.matrixWorldInverse ); + tempPosition.applyMatrix4( camera.projectionMatrix ); + + // setup arrays for gl programs + + screenPosition.copy( tempPosition ); + + // horizontal and vertical coordinate of the lower left corner of the pixels to copy + + screenPositionPixels.x = viewport.x + ( screenPosition.x * halfViewportWidth ) + halfViewportWidth - 8; + screenPositionPixels.y = viewport.y + ( screenPosition.y * halfViewportHeight ) + halfViewportHeight - 8; + + // screen cull + + if ( validArea.containsPoint( screenPositionPixels ) === true ) { + + // save current RGB to temp texture + + state.activeTexture( gl.TEXTURE0 ); + state.bindTexture( gl.TEXTURE_2D, null ); + state.activeTexture( gl.TEXTURE1 ); + state.bindTexture( gl.TEXTURE_2D, tempTexture ); + gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 ); + + + // render pink quad + + gl.uniform1i( uniforms.renderType, 0 ); + gl.uniform2f( uniforms.scale, scale.x, scale.y ); + gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z ); + + state.disable( gl.BLEND ); + state.enable( gl.DEPTH_TEST ); + + gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); + + + // copy result to occlusionMap + + state.activeTexture( gl.TEXTURE0 ); + state.bindTexture( gl.TEXTURE_2D, occlusionTexture ); + gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 ); + + + // restore graphics + + gl.uniform1i( uniforms.renderType, 1 ); + state.disable( gl.DEPTH_TEST ); + + state.activeTexture( gl.TEXTURE1 ); + state.bindTexture( gl.TEXTURE_2D, tempTexture ); + gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); + + + // update object positions + + flare.positionScreen.copy( screenPosition ); + + if ( flare.customUpdateCallback ) { + + flare.customUpdateCallback( flare ); + + } else { + + flare.updateLensFlares(); + + } + + // render flares + + gl.uniform1i( uniforms.renderType, 2 ); + state.enable( gl.BLEND ); + + for ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) { + + var sprite = flare.lensFlares[ j ]; + + if ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) { + + screenPosition.x = sprite.x; + screenPosition.y = sprite.y; + screenPosition.z = sprite.z; + + size = sprite.size * sprite.scale / viewport.w; + + scale.x = size * invAspect; + scale.y = size; + + gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z ); + gl.uniform2f( uniforms.scale, scale.x, scale.y ); + gl.uniform1f( uniforms.rotation, sprite.rotation ); + + gl.uniform1f( uniforms.opacity, sprite.opacity ); + gl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b ); + + state.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst ); + + textures.setTexture2D( sprite.texture, 1 ); + + gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); + + } + + } + + } + + } + + // restore gl + + state.enable( gl.CULL_FACE ); + state.enable( gl.DEPTH_TEST ); + state.buffers.depth.setMask( true ); + + state.reset(); + + }; + + function createProgram( shader ) { + + var program = gl.createProgram(); + + var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER ); + var vertexShader = gl.createShader( gl.VERTEX_SHADER ); + + var prefix = 'precision ' + capabilities.precision + ' float;\n'; + + gl.shaderSource( fragmentShader, prefix + shader.fragmentShader ); + gl.shaderSource( vertexShader, prefix + shader.vertexShader ); + + gl.compileShader( fragmentShader ); + gl.compileShader( vertexShader ); + + gl.attachShader( program, fragmentShader ); + gl.attachShader( program, vertexShader ); + + gl.linkProgram( program ); + + return program; + + } + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { + + Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); + + this.needsUpdate = true; + + } + + CanvasTexture.prototype = Object.create( Texture.prototype ); + CanvasTexture.prototype.constructor = CanvasTexture; + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + */ + + function WebGLSpriteRenderer( renderer, gl, state, textures, capabilities ) { + + var vertexBuffer, elementBuffer; + var program, attributes, uniforms; + + var texture; + + // decompose matrixWorld + + var spritePosition = new Vector3(); + var spriteRotation = new Quaternion(); + var spriteScale = new Vector3(); + + function init() { + + var vertices = new Float32Array( [ + - 0.5, - 0.5, 0, 0, + 0.5, - 0.5, 1, 0, + 0.5, 0.5, 1, 1, + - 0.5, 0.5, 0, 1 + ] ); + + var faces = new Uint16Array( [ + 0, 1, 2, + 0, 2, 3 + ] ); + + vertexBuffer = gl.createBuffer(); + elementBuffer = gl.createBuffer(); + + gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); + gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); + + gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); + gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW ); + + program = createProgram(); + + attributes = { + position: gl.getAttribLocation( program, 'position' ), + uv: gl.getAttribLocation( program, 'uv' ) + }; + + uniforms = { + uvOffset: gl.getUniformLocation( program, 'uvOffset' ), + uvScale: gl.getUniformLocation( program, 'uvScale' ), + + rotation: gl.getUniformLocation( program, 'rotation' ), + scale: gl.getUniformLocation( program, 'scale' ), + + color: gl.getUniformLocation( program, 'color' ), + map: gl.getUniformLocation( program, 'map' ), + opacity: gl.getUniformLocation( program, 'opacity' ), + + modelViewMatrix: gl.getUniformLocation( program, 'modelViewMatrix' ), + projectionMatrix: gl.getUniformLocation( program, 'projectionMatrix' ), + + fogType: gl.getUniformLocation( program, 'fogType' ), + fogDensity: gl.getUniformLocation( program, 'fogDensity' ), + fogNear: gl.getUniformLocation( program, 'fogNear' ), + fogFar: gl.getUniformLocation( program, 'fogFar' ), + fogColor: gl.getUniformLocation( program, 'fogColor' ), + fogDepth: gl.getUniformLocation( program, 'fogDepth' ), + + alphaTest: gl.getUniformLocation( program, 'alphaTest' ) + }; + + var canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ); + canvas.width = 8; + canvas.height = 8; + + var context = canvas.getContext( '2d' ); + context.fillStyle = 'white'; + context.fillRect( 0, 0, 8, 8 ); + + texture = new CanvasTexture( canvas ); + + } + + this.render = function ( sprites, scene, camera ) { + + if ( sprites.length === 0 ) return; + + // setup gl + + if ( program === undefined ) { + + init(); + + } + + state.useProgram( program ); + + state.initAttributes(); + state.enableAttribute( attributes.position ); + state.enableAttribute( attributes.uv ); + state.disableUnusedAttributes(); + + state.disable( gl.CULL_FACE ); + state.enable( gl.BLEND ); + + gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); + gl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 ); + gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 ); + + gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); + + gl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements ); + + state.activeTexture( gl.TEXTURE0 ); + gl.uniform1i( uniforms.map, 0 ); + + var oldFogType = 0; + var sceneFogType = 0; + var fog = scene.fog; + + if ( fog ) { + + gl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b ); + + if ( fog.isFog ) { + + gl.uniform1f( uniforms.fogNear, fog.near ); + gl.uniform1f( uniforms.fogFar, fog.far ); + + gl.uniform1i( uniforms.fogType, 1 ); + oldFogType = 1; + sceneFogType = 1; + + } else if ( fog.isFogExp2 ) { + + gl.uniform1f( uniforms.fogDensity, fog.density ); + + gl.uniform1i( uniforms.fogType, 2 ); + oldFogType = 2; + sceneFogType = 2; + + } + + } else { + + gl.uniform1i( uniforms.fogType, 0 ); + oldFogType = 0; + sceneFogType = 0; + + } + + + // update positions and sort + + for ( var i = 0, l = sprites.length; i < l; i ++ ) { + + var sprite = sprites[ i ]; + + sprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld ); + sprite.z = - sprite.modelViewMatrix.elements[ 14 ]; + + } + + sprites.sort( painterSortStable ); + + // render all sprites + + var scale = []; + + for ( var i = 0, l = sprites.length; i < l; i ++ ) { + + var sprite = sprites[ i ]; + var material = sprite.material; + + if ( material.visible === false ) continue; + + sprite.onBeforeRender( renderer, scene, camera, undefined, material, undefined ); + + gl.uniform1f( uniforms.alphaTest, material.alphaTest ); + gl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements ); + + sprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale ); + + scale[ 0 ] = spriteScale.x; + scale[ 1 ] = spriteScale.y; + + var fogType = 0; + + if ( scene.fog && material.fog ) { + + fogType = sceneFogType; + + } + + if ( oldFogType !== fogType ) { + + gl.uniform1i( uniforms.fogType, fogType ); + oldFogType = fogType; + + } + + if ( material.map !== null ) { + + gl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y ); + gl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y ); + + } else { + + gl.uniform2f( uniforms.uvOffset, 0, 0 ); + gl.uniform2f( uniforms.uvScale, 1, 1 ); + + } + + gl.uniform1f( uniforms.opacity, material.opacity ); + gl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b ); + + gl.uniform1f( uniforms.rotation, material.rotation ); + gl.uniform2fv( uniforms.scale, scale ); + + state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha ); + state.buffers.depth.setTest( material.depthTest ); + state.buffers.depth.setMask( material.depthWrite ); + state.buffers.color.setMask( material.colorWrite ); + + textures.setTexture2D( material.map || texture, 0 ); + + gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); + + sprite.onAfterRender( renderer, scene, camera, undefined, material, undefined ); + + } + + // restore gl + + state.enable( gl.CULL_FACE ); + + state.reset(); + + }; + + function createProgram() { + + var program = gl.createProgram(); + + var vertexShader = gl.createShader( gl.VERTEX_SHADER ); + var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER ); + + gl.shaderSource( vertexShader, [ + + 'precision ' + capabilities.precision + ' float;', + + '#define SHADER_NAME ' + 'SpriteMaterial', + + 'uniform mat4 modelViewMatrix;', + 'uniform mat4 projectionMatrix;', + 'uniform float rotation;', + 'uniform vec2 scale;', + 'uniform vec2 uvOffset;', + 'uniform vec2 uvScale;', + + 'attribute vec2 position;', + 'attribute vec2 uv;', + + 'varying vec2 vUV;', + 'varying float fogDepth;', + + 'void main() {', + + ' vUV = uvOffset + uv * uvScale;', + + ' vec2 alignedPosition = position * scale;', + + ' vec2 rotatedPosition;', + ' rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;', + ' rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;', + + ' vec4 mvPosition;', + + ' mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );', + ' mvPosition.xy += rotatedPosition;', + + ' gl_Position = projectionMatrix * mvPosition;', + + ' fogDepth = - mvPosition.z;', + + '}' + + ].join( '\n' ) ); + + gl.shaderSource( fragmentShader, [ + + 'precision ' + capabilities.precision + ' float;', + + '#define SHADER_NAME ' + 'SpriteMaterial', + + 'uniform vec3 color;', + 'uniform sampler2D map;', + 'uniform float opacity;', + + 'uniform int fogType;', + 'uniform vec3 fogColor;', + 'uniform float fogDensity;', + 'uniform float fogNear;', + 'uniform float fogFar;', + 'uniform float alphaTest;', + + 'varying vec2 vUV;', + 'varying float fogDepth;', + + 'void main() {', + + ' vec4 texture = texture2D( map, vUV );', + + ' gl_FragColor = vec4( color * texture.xyz, texture.a * opacity );', + + ' if ( gl_FragColor.a < alphaTest ) discard;', + + ' if ( fogType > 0 ) {', + + ' float fogFactor = 0.0;', + + ' if ( fogType == 1 ) {', + + ' fogFactor = smoothstep( fogNear, fogFar, fogDepth );', + + ' } else {', + + ' const float LOG2 = 1.442695;', + ' fogFactor = exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 );', + ' fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );', + + ' }', + + ' gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );', + + ' }', + + '}' + + ].join( '\n' ) ); + + gl.compileShader( vertexShader ); + gl.compileShader( fragmentShader ); + + gl.attachShader( program, vertexShader ); + gl.attachShader( program, fragmentShader ); + + gl.linkProgram( program ); + + return program; + + } + + function painterSortStable( a, b ) { + + if ( a.renderOrder !== b.renderOrder ) { + + return a.renderOrder - b.renderOrder; + + } else if ( a.z !== b.z ) { + + return b.z - a.z; + + } else { + + return b.id - a.id; + + } + + } + + } + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + var materialId = 0; + + function Material() { + + Object.defineProperty( this, 'id', { value: materialId ++ } ); + + this.uuid = _Math.generateUUID(); + + this.name = ''; + this.type = 'Material'; + + this.fog = true; + this.lights = true; + + this.blending = NormalBlending; + this.side = FrontSide; + this.flatShading = false; + this.vertexColors = NoColors; // THREE.NoColors, THREE.VertexColors, THREE.FaceColors + + this.opacity = 1; + this.transparent = false; + + this.blendSrc = SrcAlphaFactor; + this.blendDst = OneMinusSrcAlphaFactor; + this.blendEquation = AddEquation; + this.blendSrcAlpha = null; + this.blendDstAlpha = null; + this.blendEquationAlpha = null; + + this.depthFunc = LessEqualDepth; + this.depthTest = true; + this.depthWrite = true; + + this.clippingPlanes = null; + this.clipIntersection = false; + this.clipShadows = false; + + this.colorWrite = true; + + this.precision = null; // override the renderer's default precision for this material + + this.polygonOffset = false; + this.polygonOffsetFactor = 0; + this.polygonOffsetUnits = 0; + + this.dithering = false; + + this.alphaTest = 0; + this.premultipliedAlpha = false; + + this.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer + + this.visible = true; + + this.userData = {}; + + this.needsUpdate = true; + + } + + Material.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: Material, + + isMaterial: true, + + onBeforeCompile: function () {}, + + setValues: function ( values ) { + + if ( values === undefined ) return; + + for ( var key in values ) { + + var newValue = values[ key ]; + + if ( newValue === undefined ) { + + console.warn( "THREE.Material: '" + key + "' parameter is undefined." ); + continue; + + } + + // for backward compatability if shading is set in the constructor + if ( key === 'shading' ) { + + console.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' ); + this.flatShading = ( newValue === FlatShading ) ? true : false; + continue; + + } + + var currentValue = this[ key ]; + + if ( currentValue === undefined ) { + + console.warn( "THREE." + this.type + ": '" + key + "' is not a property of this material." ); + continue; + + } + + if ( currentValue && currentValue.isColor ) { + + currentValue.set( newValue ); + + } else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) { + + currentValue.copy( newValue ); + + } else if ( key === 'overdraw' ) { + + // ensure overdraw is backwards-compatible with legacy boolean type + this[ key ] = Number( newValue ); + + } else { + + this[ key ] = newValue; + + } + + } + + }, + + toJSON: function ( meta ) { + + var isRoot = ( meta === undefined || typeof meta === 'string' ); + + if ( isRoot ) { + + meta = { + textures: {}, + images: {} + }; + + } + + var data = { + metadata: { + version: 4.5, + type: 'Material', + generator: 'Material.toJSON' + } + }; + + // standard Material serialization + data.uuid = this.uuid; + data.type = this.type; + + if ( this.name !== '' ) data.name = this.name; + + if ( this.color && this.color.isColor ) data.color = this.color.getHex(); + + if ( this.roughness !== undefined ) data.roughness = this.roughness; + if ( this.metalness !== undefined ) data.metalness = this.metalness; + + if ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex(); + if ( this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity; + + if ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex(); + if ( this.shininess !== undefined ) data.shininess = this.shininess; + if ( this.clearCoat !== undefined ) data.clearCoat = this.clearCoat; + if ( this.clearCoatRoughness !== undefined ) data.clearCoatRoughness = this.clearCoatRoughness; + + if ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid; + if ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid; + if ( this.lightMap && this.lightMap.isTexture ) data.lightMap = this.lightMap.toJSON( meta ).uuid; + if ( this.bumpMap && this.bumpMap.isTexture ) { + + data.bumpMap = this.bumpMap.toJSON( meta ).uuid; + data.bumpScale = this.bumpScale; + + } + if ( this.normalMap && this.normalMap.isTexture ) { + + data.normalMap = this.normalMap.toJSON( meta ).uuid; + data.normalScale = this.normalScale.toArray(); + + } + if ( this.displacementMap && this.displacementMap.isTexture ) { + + data.displacementMap = this.displacementMap.toJSON( meta ).uuid; + data.displacementScale = this.displacementScale; + data.displacementBias = this.displacementBias; + + } + if ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid; + if ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid; + + if ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid; + if ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid; + + if ( this.envMap && this.envMap.isTexture ) { + + data.envMap = this.envMap.toJSON( meta ).uuid; + data.reflectivity = this.reflectivity; // Scale behind envMap + + } + + if ( this.gradientMap && this.gradientMap.isTexture ) { + + data.gradientMap = this.gradientMap.toJSON( meta ).uuid; + + } + + if ( this.size !== undefined ) data.size = this.size; + if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation; + + if ( this.blending !== NormalBlending ) data.blending = this.blending; + if ( this.flatShading === true ) data.flatShading = this.flatShading; + if ( this.side !== FrontSide ) data.side = this.side; + if ( this.vertexColors !== NoColors ) data.vertexColors = this.vertexColors; + + if ( this.opacity < 1 ) data.opacity = this.opacity; + if ( this.transparent === true ) data.transparent = this.transparent; + + data.depthFunc = this.depthFunc; + data.depthTest = this.depthTest; + data.depthWrite = this.depthWrite; + + // rotation (SpriteMaterial) + if ( this.rotation !== 0 ) data.rotation = this.rotation; + + if ( this.linewidth !== 1 ) data.linewidth = this.linewidth; + if ( this.dashSize !== undefined ) data.dashSize = this.dashSize; + if ( this.gapSize !== undefined ) data.gapSize = this.gapSize; + if ( this.scale !== undefined ) data.scale = this.scale; + + if ( this.dithering === true ) data.dithering = true; + + if ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest; + if ( this.premultipliedAlpha === true ) data.premultipliedAlpha = this.premultipliedAlpha; + + if ( this.wireframe === true ) data.wireframe = this.wireframe; + if ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth; + if ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap; + if ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin; + + if ( this.morphTargets === true ) data.morphTargets = true; + if ( this.skinning === true ) data.skinning = true; + + if ( this.visible === false ) data.visible = false; + if ( JSON.stringify( this.userData ) !== '{}' ) data.userData = this.userData; + + // TODO: Copied from Object3D.toJSON + + function extractFromCache( cache ) { + + var values = []; + + for ( var key in cache ) { + + var data = cache[ key ]; + delete data.metadata; + values.push( data ); + + } + + return values; + + } + + if ( isRoot ) { + + var textures = extractFromCache( meta.textures ); + var images = extractFromCache( meta.images ); + + if ( textures.length > 0 ) data.textures = textures; + if ( images.length > 0 ) data.images = images; + + } + + return data; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( source ) { + + this.name = source.name; + + this.fog = source.fog; + this.lights = source.lights; + + this.blending = source.blending; + this.side = source.side; + this.flatShading = source.flatShading; + this.vertexColors = source.vertexColors; + + this.opacity = source.opacity; + this.transparent = source.transparent; + + this.blendSrc = source.blendSrc; + this.blendDst = source.blendDst; + this.blendEquation = source.blendEquation; + this.blendSrcAlpha = source.blendSrcAlpha; + this.blendDstAlpha = source.blendDstAlpha; + this.blendEquationAlpha = source.blendEquationAlpha; + + this.depthFunc = source.depthFunc; + this.depthTest = source.depthTest; + this.depthWrite = source.depthWrite; + + this.colorWrite = source.colorWrite; + + this.precision = source.precision; + + this.polygonOffset = source.polygonOffset; + this.polygonOffsetFactor = source.polygonOffsetFactor; + this.polygonOffsetUnits = source.polygonOffsetUnits; + + this.dithering = source.dithering; + + this.alphaTest = source.alphaTest; + this.premultipliedAlpha = source.premultipliedAlpha; + + this.overdraw = source.overdraw; + + this.visible = source.visible; + this.userData = JSON.parse( JSON.stringify( source.userData ) ); + + this.clipShadows = source.clipShadows; + this.clipIntersection = source.clipIntersection; + + var srcPlanes = source.clippingPlanes, + dstPlanes = null; + + if ( srcPlanes !== null ) { + + var n = srcPlanes.length; + dstPlanes = new Array( n ); + + for ( var i = 0; i !== n; ++ i ) + dstPlanes[ i ] = srcPlanes[ i ].clone(); + + } + + this.clippingPlanes = dstPlanes; + + return this; + + }, + + dispose: function () { + + this.dispatchEvent( { type: 'dispose' } ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * @author bhouston / https://clara.io + * @author WestLangley / http://github.com/WestLangley + * + * parameters = { + * + * opacity: , + * + * map: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * displacementMap: new THREE.Texture( ), + * displacementScale: , + * displacementBias: , + * + * wireframe: , + * wireframeLinewidth: + * } + */ + + function MeshDepthMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshDepthMaterial'; + + this.depthPacking = BasicDepthPacking; + + this.skinning = false; + this.morphTargets = false; + + this.map = null; + + this.alphaMap = null; + + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + + this.wireframe = false; + this.wireframeLinewidth = 1; + + this.fog = false; + this.lights = false; + + this.setValues( parameters ); + + } + + MeshDepthMaterial.prototype = Object.create( Material.prototype ); + MeshDepthMaterial.prototype.constructor = MeshDepthMaterial; + + MeshDepthMaterial.prototype.isMeshDepthMaterial = true; + + MeshDepthMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.depthPacking = source.depthPacking; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + + this.map = source.map; + + this.alphaMap = source.alphaMap; + + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + + return this; + + }; + + /** + * @author WestLangley / http://github.com/WestLangley + * + * parameters = { + * + * referencePosition: , + * nearDistance: , + * farDistance: , + * + * skinning: , + * morphTargets: , + * + * map: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * displacementMap: new THREE.Texture( ), + * displacementScale: , + * displacementBias: + * + * } + */ + + function MeshDistanceMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshDistanceMaterial'; + + this.referencePosition = new Vector3(); + this.nearDistance = 1; + this.farDistance = 1000; + + this.skinning = false; + this.morphTargets = false; + + this.map = null; + + this.alphaMap = null; + + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + + this.fog = false; + this.lights = false; + + this.setValues( parameters ); + + } + + MeshDistanceMaterial.prototype = Object.create( Material.prototype ); + MeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial; + + MeshDistanceMaterial.prototype.isMeshDistanceMaterial = true; + + MeshDistanceMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.referencePosition.copy( source.referencePosition ); + this.nearDistance = source.nearDistance; + this.farDistance = source.farDistance; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + + this.map = source.map; + + this.alphaMap = source.alphaMap; + + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + + return this; + + }; + + /** + * @author bhouston / http://clara.io + * @author WestLangley / http://github.com/WestLangley + */ + + function Box3( min, max ) { + + this.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity ); + this.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity ); + + } + + Object.assign( Box3.prototype, { + + isBox3: true, + + set: function ( min, max ) { + + this.min.copy( min ); + this.max.copy( max ); + + return this; + + }, + + setFromArray: function ( array ) { + + var minX = + Infinity; + var minY = + Infinity; + var minZ = + Infinity; + + var maxX = - Infinity; + var maxY = - Infinity; + var maxZ = - Infinity; + + for ( var i = 0, l = array.length; i < l; i += 3 ) { + + var x = array[ i ]; + var y = array[ i + 1 ]; + var z = array[ i + 2 ]; + + if ( x < minX ) minX = x; + if ( y < minY ) minY = y; + if ( z < minZ ) minZ = z; + + if ( x > maxX ) maxX = x; + if ( y > maxY ) maxY = y; + if ( z > maxZ ) maxZ = z; + + } + + this.min.set( minX, minY, minZ ); + this.max.set( maxX, maxY, maxZ ); + + return this; + + }, + + setFromBufferAttribute: function ( attribute ) { + + var minX = + Infinity; + var minY = + Infinity; + var minZ = + Infinity; + + var maxX = - Infinity; + var maxY = - Infinity; + var maxZ = - Infinity; + + for ( var i = 0, l = attribute.count; i < l; i ++ ) { + + var x = attribute.getX( i ); + var y = attribute.getY( i ); + var z = attribute.getZ( i ); + + if ( x < minX ) minX = x; + if ( y < minY ) minY = y; + if ( z < minZ ) minZ = z; + + if ( x > maxX ) maxX = x; + if ( y > maxY ) maxY = y; + if ( z > maxZ ) maxZ = z; + + } + + this.min.set( minX, minY, minZ ); + this.max.set( maxX, maxY, maxZ ); + + return this; + + }, + + setFromPoints: function ( points ) { + + this.makeEmpty(); + + for ( var i = 0, il = points.length; i < il; i ++ ) { + + this.expandByPoint( points[ i ] ); + + } + + return this; + + }, + + setFromCenterAndSize: function () { + + var v1 = new Vector3(); + + return function setFromCenterAndSize( center, size ) { + + var halfSize = v1.copy( size ).multiplyScalar( 0.5 ); + + this.min.copy( center ).sub( halfSize ); + this.max.copy( center ).add( halfSize ); + + return this; + + }; + + }(), + + setFromObject: function ( object ) { + + this.makeEmpty(); + + return this.expandByObject( object ); + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( box ) { + + this.min.copy( box.min ); + this.max.copy( box.max ); + + return this; + + }, + + makeEmpty: function () { + + this.min.x = this.min.y = this.min.z = + Infinity; + this.max.x = this.max.y = this.max.z = - Infinity; + + return this; + + }, + + isEmpty: function () { + + // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes + + return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z ); + + }, + + getCenter: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return this.isEmpty() ? result.set( 0, 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 ); + + }, + + getSize: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return this.isEmpty() ? result.set( 0, 0, 0 ) : result.subVectors( this.max, this.min ); + + }, + + expandByPoint: function ( point ) { + + this.min.min( point ); + this.max.max( point ); + + return this; + + }, + + expandByVector: function ( vector ) { + + this.min.sub( vector ); + this.max.add( vector ); + + return this; + + }, + + expandByScalar: function ( scalar ) { + + this.min.addScalar( - scalar ); + this.max.addScalar( scalar ); + + return this; + + }, + + expandByObject: function () { + + // Computes the world-axis-aligned bounding box of an object (including its children), + // accounting for both the object's, and children's, world transforms + + var scope, i, l; + + var v1 = new Vector3(); + + function traverse( node ) { + + var geometry = node.geometry; + + if ( geometry !== undefined ) { + + if ( geometry.isGeometry ) { + + var vertices = geometry.vertices; + + for ( i = 0, l = vertices.length; i < l; i ++ ) { + + v1.copy( vertices[ i ] ); + v1.applyMatrix4( node.matrixWorld ); + + scope.expandByPoint( v1 ); + + } + + } else if ( geometry.isBufferGeometry ) { + + var attribute = geometry.attributes.position; + + if ( attribute !== undefined ) { + + for ( i = 0, l = attribute.count; i < l; i ++ ) { + + v1.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld ); + + scope.expandByPoint( v1 ); + + } + + } + + } + + } + + } + + return function expandByObject( object ) { + + scope = this; + + object.updateMatrixWorld( true ); + + object.traverse( traverse ); + + return this; + + }; + + }(), + + containsPoint: function ( point ) { + + return point.x < this.min.x || point.x > this.max.x || + point.y < this.min.y || point.y > this.max.y || + point.z < this.min.z || point.z > this.max.z ? false : true; + + }, + + containsBox: function ( box ) { + + return this.min.x <= box.min.x && box.max.x <= this.max.x && + this.min.y <= box.min.y && box.max.y <= this.max.y && + this.min.z <= box.min.z && box.max.z <= this.max.z; + + }, + + getParameter: function ( point, optionalTarget ) { + + // This can potentially have a divide by zero if the box + // has a size dimension of 0. + + var result = optionalTarget || new Vector3(); + + return result.set( + ( point.x - this.min.x ) / ( this.max.x - this.min.x ), + ( point.y - this.min.y ) / ( this.max.y - this.min.y ), + ( point.z - this.min.z ) / ( this.max.z - this.min.z ) + ); + + }, + + intersectsBox: function ( box ) { + + // using 6 splitting planes to rule out intersections. + return box.max.x < this.min.x || box.min.x > this.max.x || + box.max.y < this.min.y || box.min.y > this.max.y || + box.max.z < this.min.z || box.min.z > this.max.z ? false : true; + + }, + + intersectsSphere: ( function () { + + var closestPoint = new Vector3(); + + return function intersectsSphere( sphere ) { + + // Find the point on the AABB closest to the sphere center. + this.clampPoint( sphere.center, closestPoint ); + + // If that point is inside the sphere, the AABB and sphere intersect. + return closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius ); + + }; + + } )(), + + intersectsPlane: function ( plane ) { + + // We compute the minimum and maximum dot product values. If those values + // are on the same side (back or front) of the plane, then there is no intersection. + + var min, max; + + if ( plane.normal.x > 0 ) { + + min = plane.normal.x * this.min.x; + max = plane.normal.x * this.max.x; + + } else { + + min = plane.normal.x * this.max.x; + max = plane.normal.x * this.min.x; + + } + + if ( plane.normal.y > 0 ) { + + min += plane.normal.y * this.min.y; + max += plane.normal.y * this.max.y; + + } else { + + min += plane.normal.y * this.max.y; + max += plane.normal.y * this.min.y; + + } + + if ( plane.normal.z > 0 ) { + + min += plane.normal.z * this.min.z; + max += plane.normal.z * this.max.z; + + } else { + + min += plane.normal.z * this.max.z; + max += plane.normal.z * this.min.z; + + } + + return ( min <= plane.constant && max >= plane.constant ); + + }, + + clampPoint: function ( point, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return result.copy( point ).clamp( this.min, this.max ); + + }, + + distanceToPoint: function () { + + var v1 = new Vector3(); + + return function distanceToPoint( point ) { + + var clampedPoint = v1.copy( point ).clamp( this.min, this.max ); + return clampedPoint.sub( point ).length(); + + }; + + }(), + + getBoundingSphere: function () { + + var v1 = new Vector3(); + + return function getBoundingSphere( optionalTarget ) { + + var result = optionalTarget || new Sphere(); + + this.getCenter( result.center ); + + result.radius = this.getSize( v1 ).length() * 0.5; + + return result; + + }; + + }(), + + intersect: function ( box ) { + + this.min.max( box.min ); + this.max.min( box.max ); + + // 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. + if ( this.isEmpty() ) this.makeEmpty(); + + return this; + + }, + + union: function ( box ) { + + this.min.min( box.min ); + this.max.max( box.max ); + + return this; + + }, + + applyMatrix4: function () { + + var points = [ + new Vector3(), + new Vector3(), + new Vector3(), + new Vector3(), + new Vector3(), + new Vector3(), + new Vector3(), + new Vector3() + ]; + + return function applyMatrix4( matrix ) { + + // transform of empty box is an empty box. + if ( this.isEmpty() ) return this; + + // NOTE: I am using a binary pattern to specify all 2^3 combinations below + points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000 + points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001 + points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010 + points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011 + points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100 + points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101 + points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110 + points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111 + + this.setFromPoints( points ); + + return this; + + }; + + }(), + + translate: function ( offset ) { + + this.min.add( offset ); + this.max.add( offset ); + + return this; + + }, + + equals: function ( box ) { + + return box.min.equals( this.min ) && box.max.equals( this.max ); + + } + + } ); + + /** + * @author bhouston / http://clara.io + * @author mrdoob / http://mrdoob.com/ + */ + + function Sphere( center, radius ) { + + this.center = ( center !== undefined ) ? center : new Vector3(); + this.radius = ( radius !== undefined ) ? radius : 0; + + } + + Object.assign( Sphere.prototype, { + + set: function ( center, radius ) { + + this.center.copy( center ); + this.radius = radius; + + return this; + + }, + + setFromPoints: function () { + + var box = new Box3(); + + return function setFromPoints( points, optionalCenter ) { + + var center = this.center; + + if ( optionalCenter !== undefined ) { + + center.copy( optionalCenter ); + + } else { + + box.setFromPoints( points ).getCenter( center ); + + } + + var maxRadiusSq = 0; + + for ( var i = 0, il = points.length; i < il; i ++ ) { + + maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) ); + + } + + this.radius = Math.sqrt( maxRadiusSq ); + + return this; + + }; + + }(), + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( sphere ) { + + this.center.copy( sphere.center ); + this.radius = sphere.radius; + + return this; + + }, + + empty: function () { + + return ( this.radius <= 0 ); + + }, + + containsPoint: function ( point ) { + + return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) ); + + }, + + distanceToPoint: function ( point ) { + + return ( point.distanceTo( this.center ) - this.radius ); + + }, + + intersectsSphere: function ( sphere ) { + + var radiusSum = this.radius + sphere.radius; + + return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum ); + + }, + + intersectsBox: function ( box ) { + + return box.intersectsSphere( this ); + + }, + + intersectsPlane: function ( plane ) { + + return Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius; + + }, + + clampPoint: function ( point, optionalTarget ) { + + var deltaLengthSq = this.center.distanceToSquared( point ); + + var result = optionalTarget || new Vector3(); + + result.copy( point ); + + if ( deltaLengthSq > ( this.radius * this.radius ) ) { + + result.sub( this.center ).normalize(); + result.multiplyScalar( this.radius ).add( this.center ); + + } + + return result; + + }, + + getBoundingBox: function ( optionalTarget ) { + + var box = optionalTarget || new Box3(); + + box.set( this.center, this.center ); + box.expandByScalar( this.radius ); + + return box; + + }, + + applyMatrix4: function ( matrix ) { + + this.center.applyMatrix4( matrix ); + this.radius = this.radius * matrix.getMaxScaleOnAxis(); + + return this; + + }, + + translate: function ( offset ) { + + this.center.add( offset ); + + return this; + + }, + + equals: function ( sphere ) { + + return sphere.center.equals( this.center ) && ( sphere.radius === this.radius ); + + } + + } ); + + /** + * @author bhouston / http://clara.io + */ + + function Plane( normal, constant ) { + + // normal is assumed to be normalized + + this.normal = ( normal !== undefined ) ? normal : new Vector3( 1, 0, 0 ); + this.constant = ( constant !== undefined ) ? constant : 0; + + } + + Object.assign( Plane.prototype, { + + set: function ( normal, constant ) { + + this.normal.copy( normal ); + this.constant = constant; + + return this; + + }, + + setComponents: function ( x, y, z, w ) { + + this.normal.set( x, y, z ); + this.constant = w; + + return this; + + }, + + setFromNormalAndCoplanarPoint: function ( normal, point ) { + + this.normal.copy( normal ); + this.constant = - point.dot( this.normal ); + + return this; + + }, + + setFromCoplanarPoints: function () { + + var v1 = new Vector3(); + var v2 = new Vector3(); + + return function setFromCoplanarPoints( a, b, c ) { + + var normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize(); + + // Q: should an error be thrown if normal is zero (e.g. degenerate plane)? + + this.setFromNormalAndCoplanarPoint( normal, a ); + + return this; + + }; + + }(), + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( plane ) { + + this.normal.copy( plane.normal ); + this.constant = plane.constant; + + return this; + + }, + + normalize: function () { + + // Note: will lead to a divide by zero if the plane is invalid. + + var inverseNormalLength = 1.0 / this.normal.length(); + this.normal.multiplyScalar( inverseNormalLength ); + this.constant *= inverseNormalLength; + + return this; + + }, + + negate: function () { + + this.constant *= - 1; + this.normal.negate(); + + return this; + + }, + + distanceToPoint: function ( point ) { + + return this.normal.dot( point ) + this.constant; + + }, + + distanceToSphere: function ( sphere ) { + + return this.distanceToPoint( sphere.center ) - sphere.radius; + + }, + + projectPoint: function ( point, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + return result.copy( this.normal ).multiplyScalar( - this.distanceToPoint( point ) ).add( point ); + + }, + + intersectLine: function () { + + var v1 = new Vector3(); + + return function intersectLine( line, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + var direction = line.delta( v1 ); + + var denominator = this.normal.dot( direction ); + + if ( denominator === 0 ) { + + // line is coplanar, return origin + if ( this.distanceToPoint( line.start ) === 0 ) { + + return result.copy( line.start ); + + } + + // Unsure if this is the correct method to handle this case. + return undefined; + + } + + var t = - ( line.start.dot( this.normal ) + this.constant ) / denominator; + + if ( t < 0 || t > 1 ) { + + return undefined; + + } + + return result.copy( direction ).multiplyScalar( t ).add( line.start ); + + }; + + }(), + + intersectsLine: function ( line ) { + + // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it. + + var startSign = this.distanceToPoint( line.start ); + var endSign = this.distanceToPoint( line.end ); + + return ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 ); + + }, + + intersectsBox: function ( box ) { + + return box.intersectsPlane( this ); + + }, + + intersectsSphere: function ( sphere ) { + + return sphere.intersectsPlane( this ); + + }, + + coplanarPoint: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + return result.copy( this.normal ).multiplyScalar( - this.constant ); + + }, + + applyMatrix4: function () { + + var v1 = new Vector3(); + var m1 = new Matrix3(); + + return function applyMatrix4( matrix, optionalNormalMatrix ) { + + var normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix ); + + var referencePoint = this.coplanarPoint( v1 ).applyMatrix4( matrix ); + + var normal = this.normal.applyMatrix3( normalMatrix ).normalize(); + + this.constant = - referencePoint.dot( normal ); + + return this; + + }; + + }(), + + translate: function ( offset ) { + + this.constant -= offset.dot( this.normal ); + + return this; + + }, + + equals: function ( plane ) { + + return plane.normal.equals( this.normal ) && ( plane.constant === this.constant ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * @author bhouston / http://clara.io + */ + + function Frustum( p0, p1, p2, p3, p4, p5 ) { + + this.planes = [ + + ( p0 !== undefined ) ? p0 : new Plane(), + ( p1 !== undefined ) ? p1 : new Plane(), + ( p2 !== undefined ) ? p2 : new Plane(), + ( p3 !== undefined ) ? p3 : new Plane(), + ( p4 !== undefined ) ? p4 : new Plane(), + ( p5 !== undefined ) ? p5 : new Plane() + + ]; + + } + + Object.assign( Frustum.prototype, { + + set: function ( p0, p1, p2, p3, p4, p5 ) { + + var planes = this.planes; + + planes[ 0 ].copy( p0 ); + planes[ 1 ].copy( p1 ); + planes[ 2 ].copy( p2 ); + planes[ 3 ].copy( p3 ); + planes[ 4 ].copy( p4 ); + planes[ 5 ].copy( p5 ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( frustum ) { + + var planes = this.planes; + + for ( var i = 0; i < 6; i ++ ) { + + planes[ i ].copy( frustum.planes[ i ] ); + + } + + return this; + + }, + + setFromMatrix: function ( m ) { + + var planes = this.planes; + var me = m.elements; + var me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ]; + var me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ]; + var me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ]; + var me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ]; + + planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize(); + planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize(); + planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize(); + planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize(); + planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize(); + planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize(); + + return this; + + }, + + intersectsObject: function () { + + var sphere = new Sphere(); + + return function intersectsObject( object ) { + + var geometry = object.geometry; + + if ( geometry.boundingSphere === null ) + geometry.computeBoundingSphere(); + + sphere.copy( geometry.boundingSphere ) + .applyMatrix4( object.matrixWorld ); + + return this.intersectsSphere( sphere ); + + }; + + }(), + + intersectsSprite: function () { + + var sphere = new Sphere(); + + return function intersectsSprite( sprite ) { + + sphere.center.set( 0, 0, 0 ); + sphere.radius = 0.7071067811865476; + sphere.applyMatrix4( sprite.matrixWorld ); + + return this.intersectsSphere( sphere ); + + }; + + }(), + + intersectsSphere: function ( sphere ) { + + var planes = this.planes; + var center = sphere.center; + var negRadius = - sphere.radius; + + for ( var i = 0; i < 6; i ++ ) { + + var distance = planes[ i ].distanceToPoint( center ); + + if ( distance < negRadius ) { + + return false; + + } + + } + + return true; + + }, + + intersectsBox: function () { + + var p1 = new Vector3(), + p2 = new Vector3(); + + return function intersectsBox( box ) { + + var planes = this.planes; + + for ( var i = 0; i < 6; i ++ ) { + + var plane = planes[ i ]; + + p1.x = plane.normal.x > 0 ? box.min.x : box.max.x; + p2.x = plane.normal.x > 0 ? box.max.x : box.min.x; + p1.y = plane.normal.y > 0 ? box.min.y : box.max.y; + p2.y = plane.normal.y > 0 ? box.max.y : box.min.y; + p1.z = plane.normal.z > 0 ? box.min.z : box.max.z; + p2.z = plane.normal.z > 0 ? box.max.z : box.min.z; + + var d1 = plane.distanceToPoint( p1 ); + var d2 = plane.distanceToPoint( p2 ); + + // if both outside plane, no intersection + + if ( d1 < 0 && d2 < 0 ) { + + return false; + + } + + } + + return true; + + }; + + }(), + + containsPoint: function ( point ) { + + var planes = this.planes; + + for ( var i = 0; i < 6; i ++ ) { + + if ( planes[ i ].distanceToPoint( point ) < 0 ) { + + return false; + + } + + } + + return true; + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLShadowMap( _renderer, _objects, maxTextureSize ) { + + var _frustum = new Frustum(), + _projScreenMatrix = new Matrix4(), + + _shadowMapSize = new Vector2(), + _maxShadowMapSize = new Vector2( maxTextureSize, maxTextureSize ), + + _lookTarget = new Vector3(), + _lightPositionWorld = new Vector3(), + + _MorphingFlag = 1, + _SkinningFlag = 2, + + _NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1, + + _depthMaterials = new Array( _NumberOfMaterialVariants ), + _distanceMaterials = new Array( _NumberOfMaterialVariants ), + + _materialCache = {}; + + var cubeDirections = [ + new Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ), + new Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 ) + ]; + + var cubeUps = [ + new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), + new Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ), new Vector3( 0, 0, - 1 ) + ]; + + var cube2DViewPorts = [ + new Vector4(), new Vector4(), new Vector4(), + new Vector4(), new Vector4(), new Vector4() + ]; + + // init + + for ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) { + + var useMorphing = ( i & _MorphingFlag ) !== 0; + var useSkinning = ( i & _SkinningFlag ) !== 0; + + var depthMaterial = new MeshDepthMaterial( { + + depthPacking: RGBADepthPacking, + + morphTargets: useMorphing, + skinning: useSkinning + + } ); + + _depthMaterials[ i ] = depthMaterial; + + // + + var distanceMaterial = new MeshDistanceMaterial( { + + morphTargets: useMorphing, + skinning: useSkinning + + } ); + + _distanceMaterials[ i ] = distanceMaterial; + + } + + // + + var scope = this; + + this.enabled = false; + + this.autoUpdate = true; + this.needsUpdate = false; + + this.type = PCFShadowMap; + + this.renderReverseSided = true; + this.renderSingleSided = true; + + this.render = function ( lights, scene, camera ) { + + if ( scope.enabled === false ) return; + if ( scope.autoUpdate === false && scope.needsUpdate === false ) return; + + if ( lights.length === 0 ) return; + + // TODO Clean up (needed in case of contextlost) + var _gl = _renderer.context; + var _state = _renderer.state; + + // Set GL state for depth map. + _state.disable( _gl.BLEND ); + _state.buffers.color.setClear( 1, 1, 1, 1 ); + _state.buffers.depth.setTest( true ); + _state.setScissorTest( false ); + + // render depth map + + var faceCount; + + for ( var i = 0, il = lights.length; i < il; i ++ ) { + + var light = lights[ i ]; + var shadow = light.shadow; + var isPointLight = light && light.isPointLight; + + if ( shadow === undefined ) { + + console.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' ); + continue; + + } + + var shadowCamera = shadow.camera; + + _shadowMapSize.copy( shadow.mapSize ); + _shadowMapSize.min( _maxShadowMapSize ); + + if ( isPointLight ) { + + var vpWidth = _shadowMapSize.x; + var vpHeight = _shadowMapSize.y; + + // These viewports map a cube-map onto a 2D texture with the + // following orientation: + // + // xzXZ + // y Y + // + // X - Positive x direction + // x - Negative x direction + // Y - Positive y direction + // y - Negative y direction + // Z - Positive z direction + // z - Negative z direction + + // positive X + cube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight ); + // negative X + cube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight ); + // positive Z + cube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight ); + // negative Z + cube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight ); + // positive Y + cube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight ); + // negative Y + cube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight ); + + _shadowMapSize.x *= 4.0; + _shadowMapSize.y *= 2.0; + + } + + if ( shadow.map === null ) { + + var pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat }; + + shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars ); + shadow.map.texture.name = light.name + ".shadowMap"; + + shadowCamera.updateProjectionMatrix(); + + } + + if ( shadow.isSpotLightShadow ) { + + shadow.update( light ); + + } + + var shadowMap = shadow.map; + var shadowMatrix = shadow.matrix; + + _lightPositionWorld.setFromMatrixPosition( light.matrixWorld ); + shadowCamera.position.copy( _lightPositionWorld ); + + if ( isPointLight ) { + + faceCount = 6; + + // for point lights we set the shadow matrix to be a translation-only matrix + // equal to inverse of the light's position + + shadowMatrix.makeTranslation( - _lightPositionWorld.x, - _lightPositionWorld.y, - _lightPositionWorld.z ); + + } else { + + faceCount = 1; + + _lookTarget.setFromMatrixPosition( light.target.matrixWorld ); + shadowCamera.lookAt( _lookTarget ); + shadowCamera.updateMatrixWorld(); + + // compute shadow matrix + + shadowMatrix.set( + 0.5, 0.0, 0.0, 0.5, + 0.0, 0.5, 0.0, 0.5, + 0.0, 0.0, 0.5, 0.5, + 0.0, 0.0, 0.0, 1.0 + ); + + shadowMatrix.multiply( shadowCamera.projectionMatrix ); + shadowMatrix.multiply( shadowCamera.matrixWorldInverse ); + + } + + _renderer.setRenderTarget( shadowMap ); + _renderer.clear(); + + // render shadow map for each cube face (if omni-directional) or + // run a single pass if not + + for ( var face = 0; face < faceCount; face ++ ) { + + if ( isPointLight ) { + + _lookTarget.copy( shadowCamera.position ); + _lookTarget.add( cubeDirections[ face ] ); + shadowCamera.up.copy( cubeUps[ face ] ); + shadowCamera.lookAt( _lookTarget ); + shadowCamera.updateMatrixWorld(); + + var vpDimensions = cube2DViewPorts[ face ]; + _state.viewport( vpDimensions ); + + } + + // update camera matrices and frustum + + _projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse ); + _frustum.setFromMatrix( _projScreenMatrix ); + + // set object matrices & frustum culling + + renderObject( scene, camera, shadowCamera, isPointLight ); + + } + + } + + scope.needsUpdate = false; + + }; + + function getDepthMaterial( object, material, isPointLight, lightPositionWorld, shadowCameraNear, shadowCameraFar ) { + + var geometry = object.geometry; + + var result = null; + + var materialVariants = _depthMaterials; + var customMaterial = object.customDepthMaterial; + + if ( isPointLight ) { + + materialVariants = _distanceMaterials; + customMaterial = object.customDistanceMaterial; + + } + + if ( ! customMaterial ) { + + var useMorphing = false; + + if ( material.morphTargets ) { + + if ( geometry && geometry.isBufferGeometry ) { + + useMorphing = geometry.morphAttributes && geometry.morphAttributes.position && geometry.morphAttributes.position.length > 0; + + } else if ( geometry && geometry.isGeometry ) { + + useMorphing = geometry.morphTargets && geometry.morphTargets.length > 0; + + } + + } + + if ( object.isSkinnedMesh && material.skinning === false ) { + + console.warn( 'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object ); + + } + + var useSkinning = object.isSkinnedMesh && material.skinning; + + var variantIndex = 0; + + if ( useMorphing ) variantIndex |= _MorphingFlag; + if ( useSkinning ) variantIndex |= _SkinningFlag; + + result = materialVariants[ variantIndex ]; + + } else { + + result = customMaterial; + + } + + if ( _renderer.localClippingEnabled && + material.clipShadows === true && + material.clippingPlanes.length !== 0 ) { + + // in this case we need a unique material instance reflecting the + // appropriate state + + var keyA = result.uuid, keyB = material.uuid; + + var materialsForVariant = _materialCache[ keyA ]; + + if ( materialsForVariant === undefined ) { + + materialsForVariant = {}; + _materialCache[ keyA ] = materialsForVariant; + + } + + var cachedMaterial = materialsForVariant[ keyB ]; + + if ( cachedMaterial === undefined ) { + + cachedMaterial = result.clone(); + materialsForVariant[ keyB ] = cachedMaterial; + + } + + result = cachedMaterial; + + } + + result.visible = material.visible; + result.wireframe = material.wireframe; + + var side = material.side; + + if ( scope.renderSingleSided && side == DoubleSide ) { + + side = FrontSide; + + } + + if ( scope.renderReverseSided ) { + + if ( side === FrontSide ) side = BackSide; + else if ( side === BackSide ) side = FrontSide; + + } + + result.side = side; + + result.clipShadows = material.clipShadows; + result.clippingPlanes = material.clippingPlanes; + result.clipIntersection = material.clipIntersection; + + result.wireframeLinewidth = material.wireframeLinewidth; + result.linewidth = material.linewidth; + + if ( isPointLight && result.isMeshDistanceMaterial ) { + + result.referencePosition.copy( lightPositionWorld ); + result.nearDistance = shadowCameraNear; + result.farDistance = shadowCameraFar; + + } + + return result; + + } + + function renderObject( object, camera, shadowCamera, isPointLight ) { + + if ( object.visible === false ) return; + + var visible = object.layers.test( camera.layers ); + + if ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) { + + if ( object.castShadow && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) { + + object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld ); + + var geometry = _objects.update( object ); + var material = object.material; + + if ( Array.isArray( material ) ) { + + var groups = geometry.groups; + + for ( var k = 0, kl = groups.length; k < kl; k ++ ) { + + var group = groups[ k ]; + var groupMaterial = material[ group.materialIndex ]; + + if ( groupMaterial && groupMaterial.visible ) { + + var depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far ); + _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group ); + + } + + } + + } else if ( material.visible ) { + + var depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far ); + _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null ); + + } + + } + + } + + var children = object.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + renderObject( children[ i ], camera, shadowCamera, isPointLight ); + + } + + } + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLAttributes( gl ) { + + var buffers = {}; + + function createBuffer( attribute, bufferType ) { + + var array = attribute.array; + var usage = attribute.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW; + + var buffer = gl.createBuffer(); + + gl.bindBuffer( bufferType, buffer ); + gl.bufferData( bufferType, array, usage ); + + attribute.onUploadCallback(); + + var type = gl.FLOAT; + + if ( array instanceof Float32Array ) { + + type = gl.FLOAT; + + } else if ( array instanceof Float64Array ) { + + console.warn( 'THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.' ); + + } else if ( array instanceof Uint16Array ) { + + type = gl.UNSIGNED_SHORT; + + } else if ( array instanceof Int16Array ) { + + type = gl.SHORT; + + } else if ( array instanceof Uint32Array ) { + + type = gl.UNSIGNED_INT; + + } else if ( array instanceof Int32Array ) { + + type = gl.INT; + + } else if ( array instanceof Int8Array ) { + + type = gl.BYTE; + + } else if ( array instanceof Uint8Array ) { + + type = gl.UNSIGNED_BYTE; + + } + + return { + buffer: buffer, + type: type, + bytesPerElement: array.BYTES_PER_ELEMENT, + version: attribute.version + }; + + } + + function updateBuffer( buffer, attribute, bufferType ) { + + var array = attribute.array; + var updateRange = attribute.updateRange; + + gl.bindBuffer( bufferType, buffer ); + + if ( attribute.dynamic === false ) { + + gl.bufferData( bufferType, array, gl.STATIC_DRAW ); + + } else if ( updateRange.count === - 1 ) { + + // Not using update ranges + + gl.bufferSubData( bufferType, 0, array ); + + } else if ( updateRange.count === 0 ) { + + console.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' ); + + } else { + + gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT, + array.subarray( updateRange.offset, updateRange.offset + updateRange.count ) ); + + updateRange.count = - 1; // reset range + + } + + } + + // + + function get( attribute ) { + + if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data; + + return buffers[ attribute.uuid ]; + + } + + function remove( attribute ) { + + if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data; + + var data = buffers[ attribute.uuid ]; + + if ( data ) { + + gl.deleteBuffer( data.buffer ); + + delete buffers[ attribute.uuid ]; + + } + + } + + function update( attribute, bufferType ) { + + if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data; + + var data = buffers[ attribute.uuid ]; + + if ( data === undefined ) { + + buffers[ attribute.uuid ] = createBuffer( attribute, bufferType ); + + } else if ( data.version < attribute.version ) { + + updateBuffer( data.buffer, attribute, bufferType ); + + data.version = attribute.version; + + } + + } + + return { + + get: get, + remove: remove, + update: update + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + * @author bhouston / http://clara.io + */ + + function Euler( x, y, z, order ) { + + this._x = x || 0; + this._y = y || 0; + this._z = z || 0; + this._order = order || Euler.DefaultOrder; + + } + + Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ]; + + Euler.DefaultOrder = 'XYZ'; + + Object.defineProperties( Euler.prototype, { + + x: { + + get: function () { + + return this._x; + + }, + + set: function ( value ) { + + this._x = value; + this.onChangeCallback(); + + } + + }, + + y: { + + get: function () { + + return this._y; + + }, + + set: function ( value ) { + + this._y = value; + this.onChangeCallback(); + + } + + }, + + z: { + + get: function () { + + return this._z; + + }, + + set: function ( value ) { + + this._z = value; + this.onChangeCallback(); + + } + + }, + + order: { + + get: function () { + + return this._order; + + }, + + set: function ( value ) { + + this._order = value; + this.onChangeCallback(); + + } + + } + + } ); + + Object.assign( Euler.prototype, { + + isEuler: true, + + set: function ( x, y, z, order ) { + + this._x = x; + this._y = y; + this._z = z; + this._order = order || this._order; + + this.onChangeCallback(); + + return this; + + }, + + clone: function () { + + return new this.constructor( this._x, this._y, this._z, this._order ); + + }, + + copy: function ( euler ) { + + this._x = euler._x; + this._y = euler._y; + this._z = euler._z; + this._order = euler._order; + + this.onChangeCallback(); + + return this; + + }, + + setFromRotationMatrix: function ( m, order, update ) { + + var clamp = _Math.clamp; + + // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) + + var te = m.elements; + var m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ]; + var m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ]; + var m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ]; + + order = order || this._order; + + if ( order === 'XYZ' ) { + + this._y = Math.asin( clamp( m13, - 1, 1 ) ); + + if ( Math.abs( m13 ) < 0.99999 ) { + + this._x = Math.atan2( - m23, m33 ); + this._z = Math.atan2( - m12, m11 ); + + } else { + + this._x = Math.atan2( m32, m22 ); + this._z = 0; + + } + + } else if ( order === 'YXZ' ) { + + this._x = Math.asin( - clamp( m23, - 1, 1 ) ); + + if ( Math.abs( m23 ) < 0.99999 ) { + + this._y = Math.atan2( m13, m33 ); + this._z = Math.atan2( m21, m22 ); + + } else { + + this._y = Math.atan2( - m31, m11 ); + this._z = 0; + + } + + } else if ( order === 'ZXY' ) { + + this._x = Math.asin( clamp( m32, - 1, 1 ) ); + + if ( Math.abs( m32 ) < 0.99999 ) { + + this._y = Math.atan2( - m31, m33 ); + this._z = Math.atan2( - m12, m22 ); + + } else { + + this._y = 0; + this._z = Math.atan2( m21, m11 ); + + } + + } else if ( order === 'ZYX' ) { + + this._y = Math.asin( - clamp( m31, - 1, 1 ) ); + + if ( Math.abs( m31 ) < 0.99999 ) { + + this._x = Math.atan2( m32, m33 ); + this._z = Math.atan2( m21, m11 ); + + } else { + + this._x = 0; + this._z = Math.atan2( - m12, m22 ); + + } + + } else if ( order === 'YZX' ) { + + this._z = Math.asin( clamp( m21, - 1, 1 ) ); + + if ( Math.abs( m21 ) < 0.99999 ) { + + this._x = Math.atan2( - m23, m22 ); + this._y = Math.atan2( - m31, m11 ); + + } else { + + this._x = 0; + this._y = Math.atan2( m13, m33 ); + + } + + } else if ( order === 'XZY' ) { + + this._z = Math.asin( - clamp( m12, - 1, 1 ) ); + + if ( Math.abs( m12 ) < 0.99999 ) { + + this._x = Math.atan2( m32, m22 ); + this._y = Math.atan2( m13, m11 ); + + } else { + + this._x = Math.atan2( - m23, m33 ); + this._y = 0; + + } + + } else { + + console.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order ); + + } + + this._order = order; + + if ( update !== false ) this.onChangeCallback(); + + return this; + + }, + + setFromQuaternion: function () { + + var matrix = new Matrix4(); + + return function setFromQuaternion( q, order, update ) { + + matrix.makeRotationFromQuaternion( q ); + + return this.setFromRotationMatrix( matrix, order, update ); + + }; + + }(), + + setFromVector3: function ( v, order ) { + + return this.set( v.x, v.y, v.z, order || this._order ); + + }, + + reorder: function () { + + // WARNING: this discards revolution information -bhouston + + var q = new Quaternion(); + + return function reorder( newOrder ) { + + q.setFromEuler( this ); + + return this.setFromQuaternion( q, newOrder ); + + }; + + }(), + + equals: function ( euler ) { + + return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order ); + + }, + + fromArray: function ( array ) { + + this._x = array[ 0 ]; + this._y = array[ 1 ]; + this._z = array[ 2 ]; + if ( array[ 3 ] !== undefined ) this._order = array[ 3 ]; + + this.onChangeCallback(); + + return this; + + }, + + toArray: function ( array, offset ) { + + if ( array === undefined ) array = []; + if ( offset === undefined ) offset = 0; + + array[ offset ] = this._x; + array[ offset + 1 ] = this._y; + array[ offset + 2 ] = this._z; + array[ offset + 3 ] = this._order; + + return array; + + }, + + toVector3: function ( optionalResult ) { + + if ( optionalResult ) { + + return optionalResult.set( this._x, this._y, this._z ); + + } else { + + return new Vector3( this._x, this._y, this._z ); + + } + + }, + + onChange: function ( callback ) { + + this.onChangeCallback = callback; + + return this; + + }, + + onChangeCallback: function () {} + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Layers() { + + this.mask = 1 | 0; + + } + + Object.assign( Layers.prototype, { + + set: function ( channel ) { + + this.mask = 1 << channel | 0; + + }, + + enable: function ( channel ) { + + this.mask |= 1 << channel | 0; + + }, + + toggle: function ( channel ) { + + this.mask ^= 1 << channel | 0; + + }, + + disable: function ( channel ) { + + this.mask &= ~ ( 1 << channel | 0 ); + + }, + + test: function ( layers ) { + + return ( this.mask & layers.mask ) !== 0; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author WestLangley / http://github.com/WestLangley + * @author elephantatwork / www.elephantatwork.ch + */ + + var object3DId = 0; + + function Object3D() { + + Object.defineProperty( this, 'id', { value: object3DId ++ } ); + + this.uuid = _Math.generateUUID(); + + this.name = ''; + this.type = 'Object3D'; + + this.parent = null; + this.children = []; + + this.up = Object3D.DefaultUp.clone(); + + var position = new Vector3(); + var rotation = new Euler(); + var quaternion = new Quaternion(); + var scale = new Vector3( 1, 1, 1 ); + + function onRotationChange() { + + quaternion.setFromEuler( rotation, false ); + + } + + function onQuaternionChange() { + + rotation.setFromQuaternion( quaternion, undefined, false ); + + } + + rotation.onChange( onRotationChange ); + quaternion.onChange( onQuaternionChange ); + + Object.defineProperties( this, { + position: { + enumerable: true, + value: position + }, + rotation: { + enumerable: true, + value: rotation + }, + quaternion: { + enumerable: true, + value: quaternion + }, + scale: { + enumerable: true, + value: scale + }, + modelViewMatrix: { + value: new Matrix4() + }, + normalMatrix: { + value: new Matrix3() + } + } ); + + this.matrix = new Matrix4(); + this.matrixWorld = new Matrix4(); + + this.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate; + this.matrixWorldNeedsUpdate = false; + + this.layers = new Layers(); + this.visible = true; + + this.castShadow = false; + this.receiveShadow = false; + + this.frustumCulled = true; + this.renderOrder = 0; + + this.userData = {}; + + } + + Object3D.DefaultUp = new Vector3( 0, 1, 0 ); + Object3D.DefaultMatrixAutoUpdate = true; + + Object3D.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: Object3D, + + isObject3D: true, + + onBeforeRender: function () {}, + onAfterRender: function () {}, + + applyMatrix: function ( matrix ) { + + this.matrix.multiplyMatrices( matrix, this.matrix ); + + this.matrix.decompose( this.position, this.quaternion, this.scale ); + + }, + + applyQuaternion: function ( q ) { + + this.quaternion.premultiply( q ); + + return this; + + }, + + setRotationFromAxisAngle: function ( axis, angle ) { + + // assumes axis is normalized + + this.quaternion.setFromAxisAngle( axis, angle ); + + }, + + setRotationFromEuler: function ( euler ) { + + this.quaternion.setFromEuler( euler, true ); + + }, + + setRotationFromMatrix: function ( m ) { + + // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) + + this.quaternion.setFromRotationMatrix( m ); + + }, + + setRotationFromQuaternion: function ( q ) { + + // assumes q is normalized + + this.quaternion.copy( q ); + + }, + + rotateOnAxis: function () { + + // rotate object on axis in object space + // axis is assumed to be normalized + + var q1 = new Quaternion(); + + return function rotateOnAxis( axis, angle ) { + + q1.setFromAxisAngle( axis, angle ); + + this.quaternion.multiply( q1 ); + + return this; + + }; + + }(), + + rotateOnWorldAxis: function () { + + // rotate object on axis in world space + // axis is assumed to be normalized + // method assumes no rotated parent + + var q1 = new Quaternion(); + + return function rotateOnWorldAxis( axis, angle ) { + + q1.setFromAxisAngle( axis, angle ); + + this.quaternion.premultiply( q1 ); + + return this; + + }; + + }(), + + rotateX: function () { + + var v1 = new Vector3( 1, 0, 0 ); + + return function rotateX( angle ) { + + return this.rotateOnAxis( v1, angle ); + + }; + + }(), + + rotateY: function () { + + var v1 = new Vector3( 0, 1, 0 ); + + return function rotateY( angle ) { + + return this.rotateOnAxis( v1, angle ); + + }; + + }(), + + rotateZ: function () { + + var v1 = new Vector3( 0, 0, 1 ); + + return function rotateZ( angle ) { + + return this.rotateOnAxis( v1, angle ); + + }; + + }(), + + translateOnAxis: function () { + + // translate object by distance along axis in object space + // axis is assumed to be normalized + + var v1 = new Vector3(); + + return function translateOnAxis( axis, distance ) { + + v1.copy( axis ).applyQuaternion( this.quaternion ); + + this.position.add( v1.multiplyScalar( distance ) ); + + return this; + + }; + + }(), + + translateX: function () { + + var v1 = new Vector3( 1, 0, 0 ); + + return function translateX( distance ) { + + return this.translateOnAxis( v1, distance ); + + }; + + }(), + + translateY: function () { + + var v1 = new Vector3( 0, 1, 0 ); + + return function translateY( distance ) { + + return this.translateOnAxis( v1, distance ); + + }; + + }(), + + translateZ: function () { + + var v1 = new Vector3( 0, 0, 1 ); + + return function translateZ( distance ) { + + return this.translateOnAxis( v1, distance ); + + }; + + }(), + + localToWorld: function ( vector ) { + + return vector.applyMatrix4( this.matrixWorld ); + + }, + + worldToLocal: function () { + + var m1 = new Matrix4(); + + return function worldToLocal( vector ) { + + return vector.applyMatrix4( m1.getInverse( this.matrixWorld ) ); + + }; + + }(), + + lookAt: function () { + + // This method does not support objects with rotated and/or translated parent(s) + + var m1 = new Matrix4(); + var vector = new Vector3(); + + return function lookAt( x, y, z ) { + + if ( x.isVector3 ) { + + vector.copy( x ); + + } else { + + vector.set( x, y, z ); + + } + + if ( this.isCamera ) { + + m1.lookAt( this.position, vector, this.up ); + + } else { + + m1.lookAt( vector, this.position, this.up ); + + } + + this.quaternion.setFromRotationMatrix( m1 ); + + }; + + }(), + + add: function ( object ) { + + if ( arguments.length > 1 ) { + + for ( var i = 0; i < arguments.length; i ++ ) { + + this.add( arguments[ i ] ); + + } + + return this; + + } + + if ( object === this ) { + + console.error( "THREE.Object3D.add: object can't be added as a child of itself.", object ); + return this; + + } + + if ( ( object && object.isObject3D ) ) { + + if ( object.parent !== null ) { + + object.parent.remove( object ); + + } + + object.parent = this; + object.dispatchEvent( { type: 'added' } ); + + this.children.push( object ); + + } else { + + console.error( "THREE.Object3D.add: object not an instance of THREE.Object3D.", object ); + + } + + return this; + + }, + + remove: function ( object ) { + + if ( arguments.length > 1 ) { + + for ( var i = 0; i < arguments.length; i ++ ) { + + this.remove( arguments[ i ] ); + + } + + return this; + + } + + var index = this.children.indexOf( object ); + + if ( index !== - 1 ) { + + object.parent = null; + + object.dispatchEvent( { type: 'removed' } ); + + this.children.splice( index, 1 ); + + } + + return this; + + }, + + getObjectById: function ( id ) { + + return this.getObjectByProperty( 'id', id ); + + }, + + getObjectByName: function ( name ) { + + return this.getObjectByProperty( 'name', name ); + + }, + + getObjectByProperty: function ( name, value ) { + + if ( this[ name ] === value ) return this; + + for ( var i = 0, l = this.children.length; i < l; i ++ ) { + + var child = this.children[ i ]; + var object = child.getObjectByProperty( name, value ); + + if ( object !== undefined ) { + + return object; + + } + + } + + return undefined; + + }, + + getWorldPosition: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + this.updateMatrixWorld( true ); + + return result.setFromMatrixPosition( this.matrixWorld ); + + }, + + getWorldQuaternion: function () { + + var position = new Vector3(); + var scale = new Vector3(); + + return function getWorldQuaternion( optionalTarget ) { + + var result = optionalTarget || new Quaternion(); + + this.updateMatrixWorld( true ); + + this.matrixWorld.decompose( position, result, scale ); + + return result; + + }; + + }(), + + getWorldRotation: function () { + + var quaternion = new Quaternion(); + + return function getWorldRotation( optionalTarget ) { + + var result = optionalTarget || new Euler(); + + this.getWorldQuaternion( quaternion ); + + return result.setFromQuaternion( quaternion, this.rotation.order, false ); + + }; + + }(), + + getWorldScale: function () { + + var position = new Vector3(); + var quaternion = new Quaternion(); + + return function getWorldScale( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + this.updateMatrixWorld( true ); + + this.matrixWorld.decompose( position, quaternion, result ); + + return result; + + }; + + }(), + + getWorldDirection: function () { + + var quaternion = new Quaternion(); + + return function getWorldDirection( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + this.getWorldQuaternion( quaternion ); + + return result.set( 0, 0, 1 ).applyQuaternion( quaternion ); + + }; + + }(), + + raycast: function () {}, + + traverse: function ( callback ) { + + callback( this ); + + var children = this.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + children[ i ].traverse( callback ); + + } + + }, + + traverseVisible: function ( callback ) { + + if ( this.visible === false ) return; + + callback( this ); + + var children = this.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + children[ i ].traverseVisible( callback ); + + } + + }, + + traverseAncestors: function ( callback ) { + + var parent = this.parent; + + if ( parent !== null ) { + + callback( parent ); + + parent.traverseAncestors( callback ); + + } + + }, + + updateMatrix: function () { + + this.matrix.compose( this.position, this.quaternion, this.scale ); + + this.matrixWorldNeedsUpdate = true; + + }, + + updateMatrixWorld: function ( force ) { + + if ( this.matrixAutoUpdate ) this.updateMatrix(); + + if ( this.matrixWorldNeedsUpdate || force ) { + + if ( this.parent === null ) { + + this.matrixWorld.copy( this.matrix ); + + } else { + + this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix ); + + } + + this.matrixWorldNeedsUpdate = false; + + force = true; + + } + + // update children + + var children = this.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + children[ i ].updateMatrixWorld( force ); + + } + + }, + + toJSON: function ( meta ) { + + // meta is a string when called from JSON.stringify + var isRootObject = ( meta === undefined || typeof meta === 'string' ); + + var output = {}; + + // meta is a hash used to collect geometries, materials. + // not providing it implies that this is the root object + // being serialized. + if ( isRootObject ) { + + // initialize meta obj + meta = { + geometries: {}, + materials: {}, + textures: {}, + images: {}, + shapes: {} + }; + + output.metadata = { + version: 4.5, + type: 'Object', + generator: 'Object3D.toJSON' + }; + + } + + // standard Object3D serialization + + var object = {}; + + object.uuid = this.uuid; + object.type = this.type; + + if ( this.name !== '' ) object.name = this.name; + if ( this.castShadow === true ) object.castShadow = true; + if ( this.receiveShadow === true ) object.receiveShadow = true; + if ( this.visible === false ) object.visible = false; + if ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData; + + object.matrix = this.matrix.toArray(); + + // + + function serialize( library, element ) { + + if ( library[ element.uuid ] === undefined ) { + + library[ element.uuid ] = element.toJSON( meta ); + + } + + return element.uuid; + + } + + if ( this.geometry !== undefined ) { + + object.geometry = serialize( meta.geometries, this.geometry ); + + var parameters = this.geometry.parameters; + + if ( parameters !== undefined && parameters.shapes !== undefined ) { + + var shapes = parameters.shapes; + + if ( Array.isArray( shapes ) ) { + + for ( var i = 0, l = shapes.length; i < l; i ++ ) { + + var shape = shapes[ i ]; + + serialize( meta.shapes, shape ); + + } + + } else { + + serialize( meta.shapes, shapes ); + + } + + } + + } + + if ( this.material !== undefined ) { + + if ( Array.isArray( this.material ) ) { + + var uuids = []; + + for ( var i = 0, l = this.material.length; i < l; i ++ ) { + + uuids.push( serialize( meta.materials, this.material[ i ] ) ); + + } + + object.material = uuids; + + } else { + + object.material = serialize( meta.materials, this.material ); + + } + + } + + // + + if ( this.children.length > 0 ) { + + object.children = []; + + for ( var i = 0; i < this.children.length; i ++ ) { + + object.children.push( this.children[ i ].toJSON( meta ).object ); + + } + + } + + if ( isRootObject ) { + + var geometries = extractFromCache( meta.geometries ); + var materials = extractFromCache( meta.materials ); + var textures = extractFromCache( meta.textures ); + var images = extractFromCache( meta.images ); + var shapes = extractFromCache( meta.shapes ); + + if ( geometries.length > 0 ) output.geometries = geometries; + if ( materials.length > 0 ) output.materials = materials; + if ( textures.length > 0 ) output.textures = textures; + if ( images.length > 0 ) output.images = images; + if ( shapes.length > 0 ) output.shapes = shapes; + + } + + output.object = object; + + return output; + + // extract data from the cache hash + // remove metadata on each item + // and return as array + function extractFromCache( cache ) { + + var values = []; + for ( var key in cache ) { + + var data = cache[ key ]; + delete data.metadata; + values.push( data ); + + } + return values; + + } + + }, + + clone: function ( recursive ) { + + return new this.constructor().copy( this, recursive ); + + }, + + copy: function ( source, recursive ) { + + if ( recursive === undefined ) recursive = true; + + this.name = source.name; + + this.up.copy( source.up ); + + this.position.copy( source.position ); + this.quaternion.copy( source.quaternion ); + this.scale.copy( source.scale ); + + this.matrix.copy( source.matrix ); + this.matrixWorld.copy( source.matrixWorld ); + + this.matrixAutoUpdate = source.matrixAutoUpdate; + this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate; + + this.layers.mask = source.layers.mask; + this.visible = source.visible; + + this.castShadow = source.castShadow; + this.receiveShadow = source.receiveShadow; + + this.frustumCulled = source.frustumCulled; + this.renderOrder = source.renderOrder; + + this.userData = JSON.parse( JSON.stringify( source.userData ) ); + + if ( recursive === true ) { + + for ( var i = 0; i < source.children.length; i ++ ) { + + var child = source.children[ i ]; + this.add( child.clone() ); + + } + + } + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author mikael emtinger / http://gomo.se/ + * @author WestLangley / http://github.com/WestLangley + */ + + function Camera() { + + Object3D.call( this ); + + this.type = 'Camera'; + + this.matrixWorldInverse = new Matrix4(); + this.projectionMatrix = new Matrix4(); + + } + + Camera.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Camera, + + isCamera: true, + + copy: function ( source, recursive ) { + + Object3D.prototype.copy.call( this, source, recursive ); + + this.matrixWorldInverse.copy( source.matrixWorldInverse ); + this.projectionMatrix.copy( source.projectionMatrix ); + + return this; + + }, + + getWorldDirection: function () { + + var quaternion = new Quaternion(); + + return function getWorldDirection( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + this.getWorldQuaternion( quaternion ); + + return result.set( 0, 0, - 1 ).applyQuaternion( quaternion ); + + }; + + }(), + + updateMatrixWorld: function ( force ) { + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + this.matrixWorldInverse.getInverse( this.matrixWorld ); + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author arose / http://github.com/arose + */ + + function OrthographicCamera( left, right, top, bottom, near, far ) { + + Camera.call( this ); + + this.type = 'OrthographicCamera'; + + this.zoom = 1; + this.view = null; + + this.left = left; + this.right = right; + this.top = top; + this.bottom = bottom; + + this.near = ( near !== undefined ) ? near : 0.1; + this.far = ( far !== undefined ) ? far : 2000; + + this.updateProjectionMatrix(); + + } + + OrthographicCamera.prototype = Object.assign( Object.create( Camera.prototype ), { + + constructor: OrthographicCamera, + + isOrthographicCamera: true, + + copy: function ( source, recursive ) { + + Camera.prototype.copy.call( this, source, recursive ); + + this.left = source.left; + this.right = source.right; + this.top = source.top; + this.bottom = source.bottom; + this.near = source.near; + this.far = source.far; + + this.zoom = source.zoom; + this.view = source.view === null ? null : Object.assign( {}, source.view ); + + return this; + + }, + + setViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) { + + if ( this.view === null ) { + + this.view = { + enabled: true, + fullWidth: 1, + fullHeight: 1, + offsetX: 0, + offsetY: 0, + width: 1, + height: 1 + }; + + } + + this.view.enabled = true; + this.view.fullWidth = fullWidth; + this.view.fullHeight = fullHeight; + this.view.offsetX = x; + this.view.offsetY = y; + this.view.width = width; + this.view.height = height; + + this.updateProjectionMatrix(); + + }, + + clearViewOffset: function () { + + if ( this.view !== null ) { + + this.view.enabled = false; + + } + + this.updateProjectionMatrix(); + + }, + + updateProjectionMatrix: function () { + + var dx = ( this.right - this.left ) / ( 2 * this.zoom ); + var dy = ( this.top - this.bottom ) / ( 2 * this.zoom ); + var cx = ( this.right + this.left ) / 2; + var cy = ( this.top + this.bottom ) / 2; + + var left = cx - dx; + var right = cx + dx; + var top = cy + dy; + var bottom = cy - dy; + + if ( this.view !== null && this.view.enabled ) { + + var zoomW = this.zoom / ( this.view.width / this.view.fullWidth ); + var zoomH = this.zoom / ( this.view.height / this.view.fullHeight ); + var scaleW = ( this.right - this.left ) / this.view.width; + var scaleH = ( this.top - this.bottom ) / this.view.height; + + left += scaleW * ( this.view.offsetX / zoomW ); + right = left + scaleW * ( this.view.width / zoomW ); + top -= scaleH * ( this.view.offsetY / zoomH ); + bottom = top - scaleH * ( this.view.height / zoomH ); + + } + + this.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far ); + + }, + + toJSON: function ( meta ) { + + var data = Object3D.prototype.toJSON.call( this, meta ); + + data.object.zoom = this.zoom; + data.object.left = this.left; + data.object.right = this.right; + data.object.top = this.top; + data.object.bottom = this.bottom; + data.object.near = this.near; + data.object.far = this.far; + + if ( this.view !== null ) data.object.view = Object.assign( {}, this.view ); + + return data; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function Face3( a, b, c, normal, color, materialIndex ) { + + this.a = a; + this.b = b; + this.c = c; + + this.normal = ( normal && normal.isVector3 ) ? normal : new Vector3(); + this.vertexNormals = Array.isArray( normal ) ? normal : []; + + this.color = ( color && color.isColor ) ? color : new Color(); + this.vertexColors = Array.isArray( color ) ? color : []; + + this.materialIndex = materialIndex !== undefined ? materialIndex : 0; + + } + + Object.assign( Face3.prototype, { + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( source ) { + + this.a = source.a; + this.b = source.b; + this.c = source.c; + + this.normal.copy( source.normal ); + this.color.copy( source.color ); + + this.materialIndex = source.materialIndex; + + for ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) { + + this.vertexNormals[ i ] = source.vertexNormals[ i ].clone(); + + } + + for ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) { + + this.vertexColors[ i ] = source.vertexColors[ i ].clone(); + + } + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author kile / http://kile.stravaganza.org/ + * @author alteredq / http://alteredqualia.com/ + * @author mikael emtinger / http://gomo.se/ + * @author zz85 / http://www.lab4games.net/zz85/blog + * @author bhouston / http://clara.io + */ + + var geometryId = 0; // Geometry uses even numbers as Id + + function Geometry() { + + Object.defineProperty( this, 'id', { value: geometryId += 2 } ); + + this.uuid = _Math.generateUUID(); + + this.name = ''; + this.type = 'Geometry'; + + this.vertices = []; + this.colors = []; + this.faces = []; + this.faceVertexUvs = [[]]; + + this.morphTargets = []; + this.morphNormals = []; + + this.skinWeights = []; + this.skinIndices = []; + + this.lineDistances = []; + + this.boundingBox = null; + this.boundingSphere = null; + + // update flags + + this.elementsNeedUpdate = false; + this.verticesNeedUpdate = false; + this.uvsNeedUpdate = false; + this.normalsNeedUpdate = false; + this.colorsNeedUpdate = false; + this.lineDistancesNeedUpdate = false; + this.groupsNeedUpdate = false; + + } + + Geometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: Geometry, + + isGeometry: true, + + applyMatrix: function ( matrix ) { + + var normalMatrix = new Matrix3().getNormalMatrix( matrix ); + + for ( var i = 0, il = this.vertices.length; i < il; i ++ ) { + + var vertex = this.vertices[ i ]; + vertex.applyMatrix4( matrix ); + + } + + for ( var i = 0, il = this.faces.length; i < il; i ++ ) { + + var face = this.faces[ i ]; + face.normal.applyMatrix3( normalMatrix ).normalize(); + + for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) { + + face.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize(); + + } + + } + + if ( this.boundingBox !== null ) { + + this.computeBoundingBox(); + + } + + if ( this.boundingSphere !== null ) { + + this.computeBoundingSphere(); + + } + + this.verticesNeedUpdate = true; + this.normalsNeedUpdate = true; + + return this; + + }, + + rotateX: function () { + + // rotate geometry around world x-axis + + var m1 = new Matrix4(); + + return function rotateX( angle ) { + + m1.makeRotationX( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + rotateY: function () { + + // rotate geometry around world y-axis + + var m1 = new Matrix4(); + + return function rotateY( angle ) { + + m1.makeRotationY( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + rotateZ: function () { + + // rotate geometry around world z-axis + + var m1 = new Matrix4(); + + return function rotateZ( angle ) { + + m1.makeRotationZ( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + translate: function () { + + // translate geometry + + var m1 = new Matrix4(); + + return function translate( x, y, z ) { + + m1.makeTranslation( x, y, z ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + scale: function () { + + // scale geometry + + var m1 = new Matrix4(); + + return function scale( x, y, z ) { + + m1.makeScale( x, y, z ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + lookAt: function () { + + var obj = new Object3D(); + + return function lookAt( vector ) { + + obj.lookAt( vector ); + + obj.updateMatrix(); + + this.applyMatrix( obj.matrix ); + + }; + + }(), + + fromBufferGeometry: function ( geometry ) { + + var scope = this; + + var indices = geometry.index !== null ? geometry.index.array : undefined; + var attributes = geometry.attributes; + + var positions = attributes.position.array; + var normals = attributes.normal !== undefined ? attributes.normal.array : undefined; + var colors = attributes.color !== undefined ? attributes.color.array : undefined; + var uvs = attributes.uv !== undefined ? attributes.uv.array : undefined; + var uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined; + + if ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = []; + + var tempNormals = []; + var tempUVs = []; + var tempUVs2 = []; + + for ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) { + + scope.vertices.push( new Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) ); + + if ( normals !== undefined ) { + + tempNormals.push( new Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) ); + + } + + if ( colors !== undefined ) { + + scope.colors.push( new Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) ); + + } + + if ( uvs !== undefined ) { + + tempUVs.push( new Vector2( uvs[ j ], uvs[ j + 1 ] ) ); + + } + + if ( uvs2 !== undefined ) { + + tempUVs2.push( new Vector2( uvs2[ j ], uvs2[ j + 1 ] ) ); + + } + + } + + function addFace( a, b, c, materialIndex ) { + + var vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : []; + var vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : []; + + var face = new Face3( a, b, c, vertexNormals, vertexColors, materialIndex ); + + scope.faces.push( face ); + + if ( uvs !== undefined ) { + + scope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] ); + + } + + if ( uvs2 !== undefined ) { + + scope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] ); + + } + + } + + var groups = geometry.groups; + + if ( groups.length > 0 ) { + + for ( var i = 0; i < groups.length; i ++ ) { + + var group = groups[ i ]; + + var start = group.start; + var count = group.count; + + for ( var j = start, jl = start + count; j < jl; j += 3 ) { + + if ( indices !== undefined ) { + + addFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ], group.materialIndex ); + + } else { + + addFace( j, j + 1, j + 2, group.materialIndex ); + + } + + } + + } + + } else { + + if ( indices !== undefined ) { + + for ( var i = 0; i < indices.length; i += 3 ) { + + addFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] ); + + } + + } else { + + for ( var i = 0; i < positions.length / 3; i += 3 ) { + + addFace( i, i + 1, i + 2 ); + + } + + } + + } + + this.computeFaceNormals(); + + if ( geometry.boundingBox !== null ) { + + this.boundingBox = geometry.boundingBox.clone(); + + } + + if ( geometry.boundingSphere !== null ) { + + this.boundingSphere = geometry.boundingSphere.clone(); + + } + + return this; + + }, + + center: function () { + + this.computeBoundingBox(); + + var offset = this.boundingBox.getCenter().negate(); + + this.translate( offset.x, offset.y, offset.z ); + + return offset; + + }, + + normalize: function () { + + this.computeBoundingSphere(); + + var center = this.boundingSphere.center; + var radius = this.boundingSphere.radius; + + var s = radius === 0 ? 1 : 1.0 / radius; + + var matrix = new Matrix4(); + matrix.set( + s, 0, 0, - s * center.x, + 0, s, 0, - s * center.y, + 0, 0, s, - s * center.z, + 0, 0, 0, 1 + ); + + this.applyMatrix( matrix ); + + return this; + + }, + + computeFaceNormals: function () { + + var cb = new Vector3(), ab = new Vector3(); + + for ( var f = 0, fl = this.faces.length; f < fl; f ++ ) { + + var face = this.faces[ f ]; + + var vA = this.vertices[ face.a ]; + var vB = this.vertices[ face.b ]; + var vC = this.vertices[ face.c ]; + + cb.subVectors( vC, vB ); + ab.subVectors( vA, vB ); + cb.cross( ab ); + + cb.normalize(); + + face.normal.copy( cb ); + + } + + }, + + computeVertexNormals: function ( areaWeighted ) { + + if ( areaWeighted === undefined ) areaWeighted = true; + + var v, vl, f, fl, face, vertices; + + vertices = new Array( this.vertices.length ); + + for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) { + + vertices[ v ] = new Vector3(); + + } + + if ( areaWeighted ) { + + // vertex normals weighted by triangle areas + // http://www.iquilezles.org/www/articles/normals/normals.htm + + var vA, vB, vC; + var cb = new Vector3(), ab = new Vector3(); + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + vA = this.vertices[ face.a ]; + vB = this.vertices[ face.b ]; + vC = this.vertices[ face.c ]; + + cb.subVectors( vC, vB ); + ab.subVectors( vA, vB ); + cb.cross( ab ); + + vertices[ face.a ].add( cb ); + vertices[ face.b ].add( cb ); + vertices[ face.c ].add( cb ); + + } + + } else { + + this.computeFaceNormals(); + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + vertices[ face.a ].add( face.normal ); + vertices[ face.b ].add( face.normal ); + vertices[ face.c ].add( face.normal ); + + } + + } + + for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) { + + vertices[ v ].normalize(); + + } + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + var vertexNormals = face.vertexNormals; + + if ( vertexNormals.length === 3 ) { + + vertexNormals[ 0 ].copy( vertices[ face.a ] ); + vertexNormals[ 1 ].copy( vertices[ face.b ] ); + vertexNormals[ 2 ].copy( vertices[ face.c ] ); + + } else { + + vertexNormals[ 0 ] = vertices[ face.a ].clone(); + vertexNormals[ 1 ] = vertices[ face.b ].clone(); + vertexNormals[ 2 ] = vertices[ face.c ].clone(); + + } + + } + + if ( this.faces.length > 0 ) { + + this.normalsNeedUpdate = true; + + } + + }, + + computeFlatVertexNormals: function () { + + var f, fl, face; + + this.computeFaceNormals(); + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + var vertexNormals = face.vertexNormals; + + if ( vertexNormals.length === 3 ) { + + vertexNormals[ 0 ].copy( face.normal ); + vertexNormals[ 1 ].copy( face.normal ); + vertexNormals[ 2 ].copy( face.normal ); + + } else { + + vertexNormals[ 0 ] = face.normal.clone(); + vertexNormals[ 1 ] = face.normal.clone(); + vertexNormals[ 2 ] = face.normal.clone(); + + } + + } + + if ( this.faces.length > 0 ) { + + this.normalsNeedUpdate = true; + + } + + }, + + computeMorphNormals: function () { + + var i, il, f, fl, face; + + // save original normals + // - create temp variables on first access + // otherwise just copy (for faster repeated calls) + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + if ( ! face.__originalFaceNormal ) { + + face.__originalFaceNormal = face.normal.clone(); + + } else { + + face.__originalFaceNormal.copy( face.normal ); + + } + + if ( ! face.__originalVertexNormals ) face.__originalVertexNormals = []; + + for ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) { + + if ( ! face.__originalVertexNormals[ i ] ) { + + face.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone(); + + } else { + + face.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] ); + + } + + } + + } + + // use temp geometry to compute face and vertex normals for each morph + + var tmpGeo = new Geometry(); + tmpGeo.faces = this.faces; + + for ( i = 0, il = this.morphTargets.length; i < il; i ++ ) { + + // create on first access + + if ( ! this.morphNormals[ i ] ) { + + this.morphNormals[ i ] = {}; + this.morphNormals[ i ].faceNormals = []; + this.morphNormals[ i ].vertexNormals = []; + + var dstNormalsFace = this.morphNormals[ i ].faceNormals; + var dstNormalsVertex = this.morphNormals[ i ].vertexNormals; + + var faceNormal, vertexNormals; + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + faceNormal = new Vector3(); + vertexNormals = { a: new Vector3(), b: new Vector3(), c: new Vector3() }; + + dstNormalsFace.push( faceNormal ); + dstNormalsVertex.push( vertexNormals ); + + } + + } + + var morphNormals = this.morphNormals[ i ]; + + // set vertices to morph target + + tmpGeo.vertices = this.morphTargets[ i ].vertices; + + // compute morph normals + + tmpGeo.computeFaceNormals(); + tmpGeo.computeVertexNormals(); + + // store morph normals + + var faceNormal, vertexNormals; + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + faceNormal = morphNormals.faceNormals[ f ]; + vertexNormals = morphNormals.vertexNormals[ f ]; + + faceNormal.copy( face.normal ); + + vertexNormals.a.copy( face.vertexNormals[ 0 ] ); + vertexNormals.b.copy( face.vertexNormals[ 1 ] ); + vertexNormals.c.copy( face.vertexNormals[ 2 ] ); + + } + + } + + // restore original normals + + for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { + + face = this.faces[ f ]; + + face.normal = face.__originalFaceNormal; + face.vertexNormals = face.__originalVertexNormals; + + } + + }, + + computeLineDistances: function () { + + var d = 0; + var vertices = this.vertices; + + for ( var i = 0, il = vertices.length; i < il; i ++ ) { + + if ( i > 0 ) { + + d += vertices[ i ].distanceTo( vertices[ i - 1 ] ); + + } + + this.lineDistances[ i ] = d; + + } + + }, + + computeBoundingBox: function () { + + if ( this.boundingBox === null ) { + + this.boundingBox = new Box3(); + + } + + this.boundingBox.setFromPoints( this.vertices ); + + }, + + computeBoundingSphere: function () { + + if ( this.boundingSphere === null ) { + + this.boundingSphere = new Sphere(); + + } + + this.boundingSphere.setFromPoints( this.vertices ); + + }, + + merge: function ( geometry, matrix, materialIndexOffset ) { + + if ( ! ( geometry && geometry.isGeometry ) ) { + + console.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry ); + return; + + } + + var normalMatrix, + vertexOffset = this.vertices.length, + vertices1 = this.vertices, + vertices2 = geometry.vertices, + faces1 = this.faces, + faces2 = geometry.faces, + uvs1 = this.faceVertexUvs[ 0 ], + uvs2 = geometry.faceVertexUvs[ 0 ], + colors1 = this.colors, + colors2 = geometry.colors; + + if ( materialIndexOffset === undefined ) materialIndexOffset = 0; + + if ( matrix !== undefined ) { + + normalMatrix = new Matrix3().getNormalMatrix( matrix ); + + } + + // vertices + + for ( var i = 0, il = vertices2.length; i < il; i ++ ) { + + var vertex = vertices2[ i ]; + + var vertexCopy = vertex.clone(); + + if ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix ); + + vertices1.push( vertexCopy ); + + } + + // colors + + for ( var i = 0, il = colors2.length; i < il; i ++ ) { + + colors1.push( colors2[ i ].clone() ); + + } + + // faces + + for ( i = 0, il = faces2.length; i < il; i ++ ) { + + var face = faces2[ i ], faceCopy, normal, color, + faceVertexNormals = face.vertexNormals, + faceVertexColors = face.vertexColors; + + faceCopy = new Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset ); + faceCopy.normal.copy( face.normal ); + + if ( normalMatrix !== undefined ) { + + faceCopy.normal.applyMatrix3( normalMatrix ).normalize(); + + } + + for ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) { + + normal = faceVertexNormals[ j ].clone(); + + if ( normalMatrix !== undefined ) { + + normal.applyMatrix3( normalMatrix ).normalize(); + + } + + faceCopy.vertexNormals.push( normal ); + + } + + faceCopy.color.copy( face.color ); + + for ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) { + + color = faceVertexColors[ j ]; + faceCopy.vertexColors.push( color.clone() ); + + } + + faceCopy.materialIndex = face.materialIndex + materialIndexOffset; + + faces1.push( faceCopy ); + + } + + // uvs + + for ( i = 0, il = uvs2.length; i < il; i ++ ) { + + var uv = uvs2[ i ], uvCopy = []; + + if ( uv === undefined ) { + + continue; + + } + + for ( var j = 0, jl = uv.length; j < jl; j ++ ) { + + uvCopy.push( uv[ j ].clone() ); + + } + + uvs1.push( uvCopy ); + + } + + }, + + mergeMesh: function ( mesh ) { + + if ( ! ( mesh && mesh.isMesh ) ) { + + console.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh ); + return; + + } + + mesh.matrixAutoUpdate && mesh.updateMatrix(); + + this.merge( mesh.geometry, mesh.matrix ); + + }, + + /* + * Checks for duplicate vertices with hashmap. + * Duplicated vertices are removed + * and faces' vertices are updated. + */ + + mergeVertices: function () { + + var verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique) + var unique = [], changes = []; + + var v, key; + var precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001 + var precision = Math.pow( 10, precisionPoints ); + var i, il, face; + var indices, j, jl; + + for ( i = 0, il = this.vertices.length; i < il; i ++ ) { + + v = this.vertices[ i ]; + key = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision ); + + if ( verticesMap[ key ] === undefined ) { + + verticesMap[ key ] = i; + unique.push( this.vertices[ i ] ); + changes[ i ] = unique.length - 1; + + } else { + + //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]); + changes[ i ] = changes[ verticesMap[ key ] ]; + + } + + } + + + // if faces are completely degenerate after merging vertices, we + // have to remove them from the geometry. + var faceIndicesToRemove = []; + + for ( i = 0, il = this.faces.length; i < il; i ++ ) { + + face = this.faces[ i ]; + + face.a = changes[ face.a ]; + face.b = changes[ face.b ]; + face.c = changes[ face.c ]; + + indices = [ face.a, face.b, face.c ]; + + // if any duplicate vertices are found in a Face3 + // we have to remove the face as nothing can be saved + for ( var n = 0; n < 3; n ++ ) { + + if ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) { + + faceIndicesToRemove.push( i ); + break; + + } + + } + + } + + for ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) { + + var idx = faceIndicesToRemove[ i ]; + + this.faces.splice( idx, 1 ); + + for ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) { + + this.faceVertexUvs[ j ].splice( idx, 1 ); + + } + + } + + // Use unique set of vertices + + var diff = this.vertices.length - unique.length; + this.vertices = unique; + return diff; + + }, + + setFromPoints: function ( points ) { + + this.vertices = []; + + for ( var i = 0, l = points.length; i < l; i ++ ) { + + var point = points[ i ]; + this.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) ); + + } + + return this; + + }, + + sortFacesByMaterialIndex: function () { + + var faces = this.faces; + var length = faces.length; + + // tag faces + + for ( var i = 0; i < length; i ++ ) { + + faces[ i ]._id = i; + + } + + // sort faces + + function materialIndexSort( a, b ) { + + return a.materialIndex - b.materialIndex; + + } + + faces.sort( materialIndexSort ); + + // sort uvs + + var uvs1 = this.faceVertexUvs[ 0 ]; + var uvs2 = this.faceVertexUvs[ 1 ]; + + var newUvs1, newUvs2; + + if ( uvs1 && uvs1.length === length ) newUvs1 = []; + if ( uvs2 && uvs2.length === length ) newUvs2 = []; + + for ( var i = 0; i < length; i ++ ) { + + var id = faces[ i ]._id; + + if ( newUvs1 ) newUvs1.push( uvs1[ id ] ); + if ( newUvs2 ) newUvs2.push( uvs2[ id ] ); + + } + + if ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1; + if ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2; + + }, + + toJSON: function () { + + var data = { + metadata: { + version: 4.5, + type: 'Geometry', + generator: 'Geometry.toJSON' + } + }; + + // standard Geometry serialization + + data.uuid = this.uuid; + data.type = this.type; + if ( this.name !== '' ) data.name = this.name; + + if ( this.parameters !== undefined ) { + + var parameters = this.parameters; + + for ( var key in parameters ) { + + if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ]; + + } + + return data; + + } + + var vertices = []; + + for ( var i = 0; i < this.vertices.length; i ++ ) { + + var vertex = this.vertices[ i ]; + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + var faces = []; + var normals = []; + var normalsHash = {}; + var colors = []; + var colorsHash = {}; + var uvs = []; + var uvsHash = {}; + + for ( var i = 0; i < this.faces.length; i ++ ) { + + var face = this.faces[ i ]; + + var hasMaterial = true; + var hasFaceUv = false; // deprecated + var hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined; + var hasFaceNormal = face.normal.length() > 0; + var hasFaceVertexNormal = face.vertexNormals.length > 0; + var hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1; + var hasFaceVertexColor = face.vertexColors.length > 0; + + var faceType = 0; + + faceType = setBit( faceType, 0, 0 ); // isQuad + faceType = setBit( faceType, 1, hasMaterial ); + faceType = setBit( faceType, 2, hasFaceUv ); + faceType = setBit( faceType, 3, hasFaceVertexUv ); + faceType = setBit( faceType, 4, hasFaceNormal ); + faceType = setBit( faceType, 5, hasFaceVertexNormal ); + faceType = setBit( faceType, 6, hasFaceColor ); + faceType = setBit( faceType, 7, hasFaceVertexColor ); + + faces.push( faceType ); + faces.push( face.a, face.b, face.c ); + faces.push( face.materialIndex ); + + if ( hasFaceVertexUv ) { + + var faceVertexUvs = this.faceVertexUvs[ 0 ][ i ]; + + faces.push( + getUvIndex( faceVertexUvs[ 0 ] ), + getUvIndex( faceVertexUvs[ 1 ] ), + getUvIndex( faceVertexUvs[ 2 ] ) + ); + + } + + if ( hasFaceNormal ) { + + faces.push( getNormalIndex( face.normal ) ); + + } + + if ( hasFaceVertexNormal ) { + + var vertexNormals = face.vertexNormals; + + faces.push( + getNormalIndex( vertexNormals[ 0 ] ), + getNormalIndex( vertexNormals[ 1 ] ), + getNormalIndex( vertexNormals[ 2 ] ) + ); + + } + + if ( hasFaceColor ) { + + faces.push( getColorIndex( face.color ) ); + + } + + if ( hasFaceVertexColor ) { + + var vertexColors = face.vertexColors; + + faces.push( + getColorIndex( vertexColors[ 0 ] ), + getColorIndex( vertexColors[ 1 ] ), + getColorIndex( vertexColors[ 2 ] ) + ); + + } + + } + + function setBit( value, position, enabled ) { + + return enabled ? value | ( 1 << position ) : value & ( ~ ( 1 << position ) ); + + } + + function getNormalIndex( normal ) { + + var hash = normal.x.toString() + normal.y.toString() + normal.z.toString(); + + if ( normalsHash[ hash ] !== undefined ) { + + return normalsHash[ hash ]; + + } + + normalsHash[ hash ] = normals.length / 3; + normals.push( normal.x, normal.y, normal.z ); + + return normalsHash[ hash ]; + + } + + function getColorIndex( color ) { + + var hash = color.r.toString() + color.g.toString() + color.b.toString(); + + if ( colorsHash[ hash ] !== undefined ) { + + return colorsHash[ hash ]; + + } + + colorsHash[ hash ] = colors.length; + colors.push( color.getHex() ); + + return colorsHash[ hash ]; + + } + + function getUvIndex( uv ) { + + var hash = uv.x.toString() + uv.y.toString(); + + if ( uvsHash[ hash ] !== undefined ) { + + return uvsHash[ hash ]; + + } + + uvsHash[ hash ] = uvs.length / 2; + uvs.push( uv.x, uv.y ); + + return uvsHash[ hash ]; + + } + + data.data = {}; + + data.data.vertices = vertices; + data.data.normals = normals; + if ( colors.length > 0 ) data.data.colors = colors; + if ( uvs.length > 0 ) data.data.uvs = [ uvs ]; // temporal backward compatibility + data.data.faces = faces; + + return data; + + }, + + clone: function () { + + /* + // Handle primitives + + var parameters = this.parameters; + + if ( parameters !== undefined ) { + + var values = []; + + for ( var key in parameters ) { + + values.push( parameters[ key ] ); + + } + + var geometry = Object.create( this.constructor.prototype ); + this.constructor.apply( geometry, values ); + return geometry; + + } + + return new this.constructor().copy( this ); + */ + + return new Geometry().copy( this ); + + }, + + copy: function ( source ) { + + var i, il, j, jl, k, kl; + + // reset + + this.vertices = []; + this.colors = []; + this.faces = []; + this.faceVertexUvs = [[]]; + this.morphTargets = []; + this.morphNormals = []; + this.skinWeights = []; + this.skinIndices = []; + this.lineDistances = []; + this.boundingBox = null; + this.boundingSphere = null; + + // name + + this.name = source.name; + + // vertices + + var vertices = source.vertices; + + for ( i = 0, il = vertices.length; i < il; i ++ ) { + + this.vertices.push( vertices[ i ].clone() ); + + } + + // colors + + var colors = source.colors; + + for ( i = 0, il = colors.length; i < il; i ++ ) { + + this.colors.push( colors[ i ].clone() ); + + } + + // faces + + var faces = source.faces; + + for ( i = 0, il = faces.length; i < il; i ++ ) { + + this.faces.push( faces[ i ].clone() ); + + } + + // face vertex uvs + + for ( i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) { + + var faceVertexUvs = source.faceVertexUvs[ i ]; + + if ( this.faceVertexUvs[ i ] === undefined ) { + + this.faceVertexUvs[ i ] = []; + + } + + for ( j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) { + + var uvs = faceVertexUvs[ j ], uvsCopy = []; + + for ( k = 0, kl = uvs.length; k < kl; k ++ ) { + + var uv = uvs[ k ]; + + uvsCopy.push( uv.clone() ); + + } + + this.faceVertexUvs[ i ].push( uvsCopy ); + + } + + } + + // morph targets + + var morphTargets = source.morphTargets; + + for ( i = 0, il = morphTargets.length; i < il; i ++ ) { + + var morphTarget = {}; + morphTarget.name = morphTargets[ i ].name; + + // vertices + + if ( morphTargets[ i ].vertices !== undefined ) { + + morphTarget.vertices = []; + + for ( j = 0, jl = morphTargets[ i ].vertices.length; j < jl; j ++ ) { + + morphTarget.vertices.push( morphTargets[ i ].vertices[ j ].clone() ); + + } + + } + + // normals + + if ( morphTargets[ i ].normals !== undefined ) { + + morphTarget.normals = []; + + for ( j = 0, jl = morphTargets[ i ].normals.length; j < jl; j ++ ) { + + morphTarget.normals.push( morphTargets[ i ].normals[ j ].clone() ); + + } + + } + + this.morphTargets.push( morphTarget ); + + } + + // morph normals + + var morphNormals = source.morphNormals; + + for ( i = 0, il = morphNormals.length; i < il; i ++ ) { + + var morphNormal = {}; + + // vertex normals + + if ( morphNormals[ i ].vertexNormals !== undefined ) { + + morphNormal.vertexNormals = []; + + for ( j = 0, jl = morphNormals[ i ].vertexNormals.length; j < jl; j ++ ) { + + var srcVertexNormal = morphNormals[ i ].vertexNormals[ j ]; + var destVertexNormal = {}; + + destVertexNormal.a = srcVertexNormal.a.clone(); + destVertexNormal.b = srcVertexNormal.b.clone(); + destVertexNormal.c = srcVertexNormal.c.clone(); + + morphNormal.vertexNormals.push( destVertexNormal ); + + } + + } + + // face normals + + if ( morphNormals[ i ].faceNormals !== undefined ) { + + morphNormal.faceNormals = []; + + for ( j = 0, jl = morphNormals[ i ].faceNormals.length; j < jl; j ++ ) { + + morphNormal.faceNormals.push( morphNormals[ i ].faceNormals[ j ].clone() ); + + } + + } + + this.morphNormals.push( morphNormal ); + + } + + // skin weights + + var skinWeights = source.skinWeights; + + for ( i = 0, il = skinWeights.length; i < il; i ++ ) { + + this.skinWeights.push( skinWeights[ i ].clone() ); + + } + + // skin indices + + var skinIndices = source.skinIndices; + + for ( i = 0, il = skinIndices.length; i < il; i ++ ) { + + this.skinIndices.push( skinIndices[ i ].clone() ); + + } + + // line distances + + var lineDistances = source.lineDistances; + + for ( i = 0, il = lineDistances.length; i < il; i ++ ) { + + this.lineDistances.push( lineDistances[ i ] ); + + } + + // bounding box + + var boundingBox = source.boundingBox; + + if ( boundingBox !== null ) { + + this.boundingBox = boundingBox.clone(); + + } + + // bounding sphere + + var boundingSphere = source.boundingSphere; + + if ( boundingSphere !== null ) { + + this.boundingSphere = boundingSphere.clone(); + + } + + // update flags + + this.elementsNeedUpdate = source.elementsNeedUpdate; + this.verticesNeedUpdate = source.verticesNeedUpdate; + this.uvsNeedUpdate = source.uvsNeedUpdate; + this.normalsNeedUpdate = source.normalsNeedUpdate; + this.colorsNeedUpdate = source.colorsNeedUpdate; + this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate; + this.groupsNeedUpdate = source.groupsNeedUpdate; + + return this; + + }, + + dispose: function () { + + this.dispatchEvent( { type: 'dispose' } ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function BufferAttribute( array, itemSize, normalized ) { + + if ( Array.isArray( array ) ) { + + throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' ); + + } + + this.uuid = _Math.generateUUID(); + this.name = ''; + + this.array = array; + this.itemSize = itemSize; + this.count = array !== undefined ? array.length / itemSize : 0; + this.normalized = normalized === true; + + this.dynamic = false; + this.updateRange = { offset: 0, count: - 1 }; + + this.onUploadCallback = function () {}; + + this.version = 0; + + } + + Object.defineProperty( BufferAttribute.prototype, 'needsUpdate', { + + set: function ( value ) { + + if ( value === true ) this.version ++; + + } + + } ); + + Object.assign( BufferAttribute.prototype, { + + isBufferAttribute: true, + + setArray: function ( array ) { + + if ( Array.isArray( array ) ) { + + throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' ); + + } + + this.count = array !== undefined ? array.length / this.itemSize : 0; + this.array = array; + + }, + + setDynamic: function ( value ) { + + this.dynamic = value; + + return this; + + }, + + copy: function ( source ) { + + this.array = new source.array.constructor( source.array ); + this.itemSize = source.itemSize; + this.count = source.count; + this.normalized = source.normalized; + + this.dynamic = source.dynamic; + + return this; + + }, + + copyAt: function ( index1, attribute, index2 ) { + + index1 *= this.itemSize; + index2 *= attribute.itemSize; + + for ( var i = 0, l = this.itemSize; i < l; i ++ ) { + + this.array[ index1 + i ] = attribute.array[ index2 + i ]; + + } + + return this; + + }, + + copyArray: function ( array ) { + + this.array.set( array ); + + return this; + + }, + + copyColorsArray: function ( colors ) { + + var array = this.array, offset = 0; + + for ( var i = 0, l = colors.length; i < l; i ++ ) { + + var color = colors[ i ]; + + if ( color === undefined ) { + + console.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i ); + color = new Color(); + + } + + array[ offset ++ ] = color.r; + array[ offset ++ ] = color.g; + array[ offset ++ ] = color.b; + + } + + return this; + + }, + + copyIndicesArray: function ( indices ) { + + var array = this.array, offset = 0; + + for ( var i = 0, l = indices.length; i < l; i ++ ) { + + var index = indices[ i ]; + + array[ offset ++ ] = index.a; + array[ offset ++ ] = index.b; + array[ offset ++ ] = index.c; + + } + + return this; + + }, + + copyVector2sArray: function ( vectors ) { + + var array = this.array, offset = 0; + + for ( var i = 0, l = vectors.length; i < l; i ++ ) { + + var vector = vectors[ i ]; + + if ( vector === undefined ) { + + console.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i ); + vector = new Vector2(); + + } + + array[ offset ++ ] = vector.x; + array[ offset ++ ] = vector.y; + + } + + return this; + + }, + + copyVector3sArray: function ( vectors ) { + + var array = this.array, offset = 0; + + for ( var i = 0, l = vectors.length; i < l; i ++ ) { + + var vector = vectors[ i ]; + + if ( vector === undefined ) { + + console.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i ); + vector = new Vector3(); + + } + + array[ offset ++ ] = vector.x; + array[ offset ++ ] = vector.y; + array[ offset ++ ] = vector.z; + + } + + return this; + + }, + + copyVector4sArray: function ( vectors ) { + + var array = this.array, offset = 0; + + for ( var i = 0, l = vectors.length; i < l; i ++ ) { + + var vector = vectors[ i ]; + + if ( vector === undefined ) { + + console.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i ); + vector = new Vector4(); + + } + + array[ offset ++ ] = vector.x; + array[ offset ++ ] = vector.y; + array[ offset ++ ] = vector.z; + array[ offset ++ ] = vector.w; + + } + + return this; + + }, + + set: function ( value, offset ) { + + if ( offset === undefined ) offset = 0; + + this.array.set( value, offset ); + + return this; + + }, + + getX: function ( index ) { + + return this.array[ index * this.itemSize ]; + + }, + + setX: function ( index, x ) { + + this.array[ index * this.itemSize ] = x; + + return this; + + }, + + getY: function ( index ) { + + return this.array[ index * this.itemSize + 1 ]; + + }, + + setY: function ( index, y ) { + + this.array[ index * this.itemSize + 1 ] = y; + + return this; + + }, + + getZ: function ( index ) { + + return this.array[ index * this.itemSize + 2 ]; + + }, + + setZ: function ( index, z ) { + + this.array[ index * this.itemSize + 2 ] = z; + + return this; + + }, + + getW: function ( index ) { + + return this.array[ index * this.itemSize + 3 ]; + + }, + + setW: function ( index, w ) { + + this.array[ index * this.itemSize + 3 ] = w; + + return this; + + }, + + setXY: function ( index, x, y ) { + + index *= this.itemSize; + + this.array[ index + 0 ] = x; + this.array[ index + 1 ] = y; + + return this; + + }, + + setXYZ: function ( index, x, y, z ) { + + index *= this.itemSize; + + this.array[ index + 0 ] = x; + this.array[ index + 1 ] = y; + this.array[ index + 2 ] = z; + + return this; + + }, + + setXYZW: function ( index, x, y, z, w ) { + + index *= this.itemSize; + + this.array[ index + 0 ] = x; + this.array[ index + 1 ] = y; + this.array[ index + 2 ] = z; + this.array[ index + 3 ] = w; + + return this; + + }, + + onUpload: function ( callback ) { + + this.onUploadCallback = callback; + + return this; + + }, + + clone: function () { + + return new this.constructor( this.array, this.itemSize ).copy( this ); + + } + + } ); + + // + + function Int8BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Int8Array( array ), itemSize, normalized ); + + } + + Int8BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Int8BufferAttribute.prototype.constructor = Int8BufferAttribute; + + + function Uint8BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Uint8Array( array ), itemSize, normalized ); + + } + + Uint8BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Uint8BufferAttribute.prototype.constructor = Uint8BufferAttribute; + + + function Uint8ClampedBufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Uint8ClampedArray( array ), itemSize, normalized ); + + } + + Uint8ClampedBufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Uint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute; + + + function Int16BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Int16Array( array ), itemSize, normalized ); + + } + + Int16BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Int16BufferAttribute.prototype.constructor = Int16BufferAttribute; + + + function Uint16BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized ); + + } + + Uint16BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Uint16BufferAttribute.prototype.constructor = Uint16BufferAttribute; + + + function Int32BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Int32Array( array ), itemSize, normalized ); + + } + + Int32BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Int32BufferAttribute.prototype.constructor = Int32BufferAttribute; + + + function Uint32BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Uint32Array( array ), itemSize, normalized ); + + } + + Uint32BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Uint32BufferAttribute.prototype.constructor = Uint32BufferAttribute; + + + function Float32BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Float32Array( array ), itemSize, normalized ); + + } + + Float32BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Float32BufferAttribute.prototype.constructor = Float32BufferAttribute; + + + function Float64BufferAttribute( array, itemSize, normalized ) { + + BufferAttribute.call( this, new Float64Array( array ), itemSize, normalized ); + + } + + Float64BufferAttribute.prototype = Object.create( BufferAttribute.prototype ); + Float64BufferAttribute.prototype.constructor = Float64BufferAttribute; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function DirectGeometry() { + + this.indices = []; + this.vertices = []; + this.normals = []; + this.colors = []; + this.uvs = []; + this.uvs2 = []; + + this.groups = []; + + this.morphTargets = {}; + + this.skinWeights = []; + this.skinIndices = []; + + // this.lineDistances = []; + + this.boundingBox = null; + this.boundingSphere = null; + + // update flags + + this.verticesNeedUpdate = false; + this.normalsNeedUpdate = false; + this.colorsNeedUpdate = false; + this.uvsNeedUpdate = false; + this.groupsNeedUpdate = false; + + } + + Object.assign( DirectGeometry.prototype, { + + computeGroups: function ( geometry ) { + + var group; + var groups = []; + var materialIndex = undefined; + + var faces = geometry.faces; + + for ( var i = 0; i < faces.length; i ++ ) { + + var face = faces[ i ]; + + // materials + + if ( face.materialIndex !== materialIndex ) { + + materialIndex = face.materialIndex; + + if ( group !== undefined ) { + + group.count = ( i * 3 ) - group.start; + groups.push( group ); + + } + + group = { + start: i * 3, + materialIndex: materialIndex + }; + + } + + } + + if ( group !== undefined ) { + + group.count = ( i * 3 ) - group.start; + groups.push( group ); + + } + + this.groups = groups; + + }, + + fromGeometry: function ( geometry ) { + + var faces = geometry.faces; + var vertices = geometry.vertices; + var faceVertexUvs = geometry.faceVertexUvs; + + var hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 0; + var hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0; + + // morphs + + var morphTargets = geometry.morphTargets; + var morphTargetsLength = morphTargets.length; + + var morphTargetsPosition; + + if ( morphTargetsLength > 0 ) { + + morphTargetsPosition = []; + + for ( var i = 0; i < morphTargetsLength; i ++ ) { + + morphTargetsPosition[ i ] = []; + + } + + this.morphTargets.position = morphTargetsPosition; + + } + + var morphNormals = geometry.morphNormals; + var morphNormalsLength = morphNormals.length; + + var morphTargetsNormal; + + if ( morphNormalsLength > 0 ) { + + morphTargetsNormal = []; + + for ( var i = 0; i < morphNormalsLength; i ++ ) { + + morphTargetsNormal[ i ] = []; + + } + + this.morphTargets.normal = morphTargetsNormal; + + } + + // skins + + var skinIndices = geometry.skinIndices; + var skinWeights = geometry.skinWeights; + + var hasSkinIndices = skinIndices.length === vertices.length; + var hasSkinWeights = skinWeights.length === vertices.length; + + // + + for ( var i = 0; i < faces.length; i ++ ) { + + var face = faces[ i ]; + + this.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] ); + + var vertexNormals = face.vertexNormals; + + if ( vertexNormals.length === 3 ) { + + this.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] ); + + } else { + + var normal = face.normal; + + this.normals.push( normal, normal, normal ); + + } + + var vertexColors = face.vertexColors; + + if ( vertexColors.length === 3 ) { + + this.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] ); + + } else { + + var color = face.color; + + this.colors.push( color, color, color ); + + } + + if ( hasFaceVertexUv === true ) { + + var vertexUvs = faceVertexUvs[ 0 ][ i ]; + + if ( vertexUvs !== undefined ) { + + this.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] ); + + } else { + + console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i ); + + this.uvs.push( new Vector2(), new Vector2(), new Vector2() ); + + } + + } + + if ( hasFaceVertexUv2 === true ) { + + var vertexUvs = faceVertexUvs[ 1 ][ i ]; + + if ( vertexUvs !== undefined ) { + + this.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] ); + + } else { + + console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i ); + + this.uvs2.push( new Vector2(), new Vector2(), new Vector2() ); + + } + + } + + // morphs + + for ( var j = 0; j < morphTargetsLength; j ++ ) { + + var morphTarget = morphTargets[ j ].vertices; + + morphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] ); + + } + + for ( var j = 0; j < morphNormalsLength; j ++ ) { + + var morphNormal = morphNormals[ j ].vertexNormals[ i ]; + + morphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c ); + + } + + // skins + + if ( hasSkinIndices ) { + + this.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] ); + + } + + if ( hasSkinWeights ) { + + this.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] ); + + } + + } + + this.computeGroups( geometry ); + + this.verticesNeedUpdate = geometry.verticesNeedUpdate; + this.normalsNeedUpdate = geometry.normalsNeedUpdate; + this.colorsNeedUpdate = geometry.colorsNeedUpdate; + this.uvsNeedUpdate = geometry.uvsNeedUpdate; + this.groupsNeedUpdate = geometry.groupsNeedUpdate; + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function arrayMax( array ) { + + if ( array.length === 0 ) return - Infinity; + + var max = array[ 0 ]; + + for ( var i = 1, l = array.length; i < l; ++ i ) { + + if ( array[ i ] > max ) max = array[ i ]; + + } + + return max; + + } + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + */ + + var bufferGeometryId = 1; // BufferGeometry uses odd numbers as Id + + function BufferGeometry() { + + Object.defineProperty( this, 'id', { value: bufferGeometryId += 2 } ); + + this.uuid = _Math.generateUUID(); + + this.name = ''; + this.type = 'BufferGeometry'; + + this.index = null; + this.attributes = {}; + + this.morphAttributes = {}; + + this.groups = []; + + this.boundingBox = null; + this.boundingSphere = null; + + this.drawRange = { start: 0, count: Infinity }; + + } + + BufferGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: BufferGeometry, + + isBufferGeometry: true, + + getIndex: function () { + + return this.index; + + }, + + setIndex: function ( index ) { + + if ( Array.isArray( index ) ) { + + this.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 ); + + } else { + + this.index = index; + + } + + }, + + addAttribute: function ( name, attribute ) { + + if ( ! ( attribute && attribute.isBufferAttribute ) && ! ( attribute && attribute.isInterleavedBufferAttribute ) ) { + + console.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' ); + + this.addAttribute( name, new BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) ); + + return; + + } + + if ( name === 'index' ) { + + console.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' ); + this.setIndex( attribute ); + + return; + + } + + this.attributes[ name ] = attribute; + + return this; + + }, + + getAttribute: function ( name ) { + + return this.attributes[ name ]; + + }, + + removeAttribute: function ( name ) { + + delete this.attributes[ name ]; + + return this; + + }, + + addGroup: function ( start, count, materialIndex ) { + + this.groups.push( { + + start: start, + count: count, + materialIndex: materialIndex !== undefined ? materialIndex : 0 + + } ); + + }, + + clearGroups: function () { + + this.groups = []; + + }, + + setDrawRange: function ( start, count ) { + + this.drawRange.start = start; + this.drawRange.count = count; + + }, + + applyMatrix: function ( matrix ) { + + var position = this.attributes.position; + + if ( position !== undefined ) { + + matrix.applyToBufferAttribute( position ); + position.needsUpdate = true; + + } + + var normal = this.attributes.normal; + + if ( normal !== undefined ) { + + var normalMatrix = new Matrix3().getNormalMatrix( matrix ); + + normalMatrix.applyToBufferAttribute( normal ); + normal.needsUpdate = true; + + } + + if ( this.boundingBox !== null ) { + + this.computeBoundingBox(); + + } + + if ( this.boundingSphere !== null ) { + + this.computeBoundingSphere(); + + } + + return this; + + }, + + rotateX: function () { + + // rotate geometry around world x-axis + + var m1 = new Matrix4(); + + return function rotateX( angle ) { + + m1.makeRotationX( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + rotateY: function () { + + // rotate geometry around world y-axis + + var m1 = new Matrix4(); + + return function rotateY( angle ) { + + m1.makeRotationY( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + rotateZ: function () { + + // rotate geometry around world z-axis + + var m1 = new Matrix4(); + + return function rotateZ( angle ) { + + m1.makeRotationZ( angle ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + translate: function () { + + // translate geometry + + var m1 = new Matrix4(); + + return function translate( x, y, z ) { + + m1.makeTranslation( x, y, z ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + scale: function () { + + // scale geometry + + var m1 = new Matrix4(); + + return function scale( x, y, z ) { + + m1.makeScale( x, y, z ); + + this.applyMatrix( m1 ); + + return this; + + }; + + }(), + + lookAt: function () { + + var obj = new Object3D(); + + return function lookAt( vector ) { + + obj.lookAt( vector ); + + obj.updateMatrix(); + + this.applyMatrix( obj.matrix ); + + }; + + }(), + + center: function () { + + this.computeBoundingBox(); + + var offset = this.boundingBox.getCenter().negate(); + + this.translate( offset.x, offset.y, offset.z ); + + return offset; + + }, + + setFromObject: function ( object ) { + + // console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this ); + + var geometry = object.geometry; + + if ( object.isPoints || object.isLine ) { + + var positions = new Float32BufferAttribute( geometry.vertices.length * 3, 3 ); + var colors = new Float32BufferAttribute( geometry.colors.length * 3, 3 ); + + this.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) ); + this.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) ); + + if ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) { + + var lineDistances = new Float32BufferAttribute( geometry.lineDistances.length, 1 ); + + this.addAttribute( 'lineDistance', lineDistances.copyArray( geometry.lineDistances ) ); + + } + + if ( geometry.boundingSphere !== null ) { + + this.boundingSphere = geometry.boundingSphere.clone(); + + } + + if ( geometry.boundingBox !== null ) { + + this.boundingBox = geometry.boundingBox.clone(); + + } + + } else if ( object.isMesh ) { + + if ( geometry && geometry.isGeometry ) { + + this.fromGeometry( geometry ); + + } + + } + + return this; + + }, + + setFromPoints: function ( points ) { + + var position = []; + + for ( var i = 0, l = points.length; i < l; i ++ ) { + + var point = points[ i ]; + position.push( point.x, point.y, point.z || 0 ); + + } + + this.addAttribute( 'position', new Float32BufferAttribute( position, 3 ) ); + + return this; + + }, + + updateFromObject: function ( object ) { + + var geometry = object.geometry; + + if ( object.isMesh ) { + + var direct = geometry.__directGeometry; + + if ( geometry.elementsNeedUpdate === true ) { + + direct = undefined; + geometry.elementsNeedUpdate = false; + + } + + if ( direct === undefined ) { + + return this.fromGeometry( geometry ); + + } + + direct.verticesNeedUpdate = geometry.verticesNeedUpdate; + direct.normalsNeedUpdate = geometry.normalsNeedUpdate; + direct.colorsNeedUpdate = geometry.colorsNeedUpdate; + direct.uvsNeedUpdate = geometry.uvsNeedUpdate; + direct.groupsNeedUpdate = geometry.groupsNeedUpdate; + + geometry.verticesNeedUpdate = false; + geometry.normalsNeedUpdate = false; + geometry.colorsNeedUpdate = false; + geometry.uvsNeedUpdate = false; + geometry.groupsNeedUpdate = false; + + geometry = direct; + + } + + var attribute; + + if ( geometry.verticesNeedUpdate === true ) { + + attribute = this.attributes.position; + + if ( attribute !== undefined ) { + + attribute.copyVector3sArray( geometry.vertices ); + attribute.needsUpdate = true; + + } + + geometry.verticesNeedUpdate = false; + + } + + if ( geometry.normalsNeedUpdate === true ) { + + attribute = this.attributes.normal; + + if ( attribute !== undefined ) { + + attribute.copyVector3sArray( geometry.normals ); + attribute.needsUpdate = true; + + } + + geometry.normalsNeedUpdate = false; + + } + + if ( geometry.colorsNeedUpdate === true ) { + + attribute = this.attributes.color; + + if ( attribute !== undefined ) { + + attribute.copyColorsArray( geometry.colors ); + attribute.needsUpdate = true; + + } + + geometry.colorsNeedUpdate = false; + + } + + if ( geometry.uvsNeedUpdate ) { + + attribute = this.attributes.uv; + + if ( attribute !== undefined ) { + + attribute.copyVector2sArray( geometry.uvs ); + attribute.needsUpdate = true; + + } + + geometry.uvsNeedUpdate = false; + + } + + if ( geometry.lineDistancesNeedUpdate ) { + + attribute = this.attributes.lineDistance; + + if ( attribute !== undefined ) { + + attribute.copyArray( geometry.lineDistances ); + attribute.needsUpdate = true; + + } + + geometry.lineDistancesNeedUpdate = false; + + } + + if ( geometry.groupsNeedUpdate ) { + + geometry.computeGroups( object.geometry ); + this.groups = geometry.groups; + + geometry.groupsNeedUpdate = false; + + } + + return this; + + }, + + fromGeometry: function ( geometry ) { + + geometry.__directGeometry = new DirectGeometry().fromGeometry( geometry ); + + return this.fromDirectGeometry( geometry.__directGeometry ); + + }, + + fromDirectGeometry: function ( geometry ) { + + var positions = new Float32Array( geometry.vertices.length * 3 ); + this.addAttribute( 'position', new BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) ); + + if ( geometry.normals.length > 0 ) { + + var normals = new Float32Array( geometry.normals.length * 3 ); + this.addAttribute( 'normal', new BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) ); + + } + + if ( geometry.colors.length > 0 ) { + + var colors = new Float32Array( geometry.colors.length * 3 ); + this.addAttribute( 'color', new BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) ); + + } + + if ( geometry.uvs.length > 0 ) { + + var uvs = new Float32Array( geometry.uvs.length * 2 ); + this.addAttribute( 'uv', new BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) ); + + } + + if ( geometry.uvs2.length > 0 ) { + + var uvs2 = new Float32Array( geometry.uvs2.length * 2 ); + this.addAttribute( 'uv2', new BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) ); + + } + + if ( geometry.indices.length > 0 ) { + + var TypeArray = arrayMax( geometry.indices ) > 65535 ? Uint32Array : Uint16Array; + var indices = new TypeArray( geometry.indices.length * 3 ); + this.setIndex( new BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) ); + + } + + // groups + + this.groups = geometry.groups; + + // morphs + + for ( var name in geometry.morphTargets ) { + + var array = []; + var morphTargets = geometry.morphTargets[ name ]; + + for ( var i = 0, l = morphTargets.length; i < l; i ++ ) { + + var morphTarget = morphTargets[ i ]; + + var attribute = new Float32BufferAttribute( morphTarget.length * 3, 3 ); + + array.push( attribute.copyVector3sArray( morphTarget ) ); + + } + + this.morphAttributes[ name ] = array; + + } + + // skinning + + if ( geometry.skinIndices.length > 0 ) { + + var skinIndices = new Float32BufferAttribute( geometry.skinIndices.length * 4, 4 ); + this.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) ); + + } + + if ( geometry.skinWeights.length > 0 ) { + + var skinWeights = new Float32BufferAttribute( geometry.skinWeights.length * 4, 4 ); + this.addAttribute( 'skinWeight', skinWeights.copyVector4sArray( geometry.skinWeights ) ); + + } + + // + + if ( geometry.boundingSphere !== null ) { + + this.boundingSphere = geometry.boundingSphere.clone(); + + } + + if ( geometry.boundingBox !== null ) { + + this.boundingBox = geometry.boundingBox.clone(); + + } + + return this; + + }, + + computeBoundingBox: function () { + + if ( this.boundingBox === null ) { + + this.boundingBox = new Box3(); + + } + + var position = this.attributes.position; + + if ( position !== undefined ) { + + this.boundingBox.setFromBufferAttribute( position ); + + } else { + + this.boundingBox.makeEmpty(); + + } + + if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) { + + console.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this ); + + } + + }, + + computeBoundingSphere: function () { + + var box = new Box3(); + var vector = new Vector3(); + + return function computeBoundingSphere() { + + if ( this.boundingSphere === null ) { + + this.boundingSphere = new Sphere(); + + } + + var position = this.attributes.position; + + if ( position ) { + + var center = this.boundingSphere.center; + + box.setFromBufferAttribute( position ); + box.getCenter( center ); + + // hoping to find a boundingSphere with a radius smaller than the + // boundingSphere of the boundingBox: sqrt(3) smaller in the best case + + var maxRadiusSq = 0; + + for ( var i = 0, il = position.count; i < il; i ++ ) { + + vector.x = position.getX( i ); + vector.y = position.getY( i ); + vector.z = position.getZ( i ); + maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) ); + + } + + this.boundingSphere.radius = Math.sqrt( maxRadiusSq ); + + if ( isNaN( this.boundingSphere.radius ) ) { + + console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this ); + + } + + } + + }; + + }(), + + computeFaceNormals: function () { + + // backwards compatibility + + }, + + computeVertexNormals: function () { + + var index = this.index; + var attributes = this.attributes; + var groups = this.groups; + + if ( attributes.position ) { + + var positions = attributes.position.array; + + if ( attributes.normal === undefined ) { + + this.addAttribute( 'normal', new BufferAttribute( new Float32Array( positions.length ), 3 ) ); + + } else { + + // reset existing normals to zero + + var array = attributes.normal.array; + + for ( var i = 0, il = array.length; i < il; i ++ ) { + + array[ i ] = 0; + + } + + } + + var normals = attributes.normal.array; + + var vA, vB, vC; + var pA = new Vector3(), pB = new Vector3(), pC = new Vector3(); + var cb = new Vector3(), ab = new Vector3(); + + // indexed elements + + if ( index ) { + + var indices = index.array; + + if ( groups.length === 0 ) { + + this.addGroup( 0, indices.length ); + + } + + for ( var j = 0, jl = groups.length; j < jl; ++ j ) { + + var group = groups[ j ]; + + var start = group.start; + var count = group.count; + + for ( var i = start, il = start + count; i < il; i += 3 ) { + + vA = indices[ i + 0 ] * 3; + vB = indices[ i + 1 ] * 3; + vC = indices[ i + 2 ] * 3; + + pA.fromArray( positions, vA ); + pB.fromArray( positions, vB ); + pC.fromArray( positions, vC ); + + cb.subVectors( pC, pB ); + ab.subVectors( pA, pB ); + cb.cross( ab ); + + normals[ vA ] += cb.x; + normals[ vA + 1 ] += cb.y; + normals[ vA + 2 ] += cb.z; + + normals[ vB ] += cb.x; + normals[ vB + 1 ] += cb.y; + normals[ vB + 2 ] += cb.z; + + normals[ vC ] += cb.x; + normals[ vC + 1 ] += cb.y; + normals[ vC + 2 ] += cb.z; + + } + + } + + } else { + + // non-indexed elements (unconnected triangle soup) + + for ( var i = 0, il = positions.length; i < il; i += 9 ) { + + pA.fromArray( positions, i ); + pB.fromArray( positions, i + 3 ); + pC.fromArray( positions, i + 6 ); + + cb.subVectors( pC, pB ); + ab.subVectors( pA, pB ); + cb.cross( ab ); + + normals[ i ] = cb.x; + normals[ i + 1 ] = cb.y; + normals[ i + 2 ] = cb.z; + + normals[ i + 3 ] = cb.x; + normals[ i + 4 ] = cb.y; + normals[ i + 5 ] = cb.z; + + normals[ i + 6 ] = cb.x; + normals[ i + 7 ] = cb.y; + normals[ i + 8 ] = cb.z; + + } + + } + + this.normalizeNormals(); + + attributes.normal.needsUpdate = true; + + } + + }, + + merge: function ( geometry, offset ) { + + if ( ! ( geometry && geometry.isBufferGeometry ) ) { + + console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry ); + return; + + } + + if ( offset === undefined ) offset = 0; + + var attributes = this.attributes; + + for ( var key in attributes ) { + + if ( geometry.attributes[ key ] === undefined ) continue; + + var attribute1 = attributes[ key ]; + var attributeArray1 = attribute1.array; + + var attribute2 = geometry.attributes[ key ]; + var attributeArray2 = attribute2.array; + + var attributeSize = attribute2.itemSize; + + for ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) { + + attributeArray1[ j ] = attributeArray2[ i ]; + + } + + } + + return this; + + }, + + normalizeNormals: function () { + + var vector = new Vector3(); + + return function normalizeNormals() { + + var normals = this.attributes.normal; + + for ( var i = 0, il = normals.count; i < il; i ++ ) { + + vector.x = normals.getX( i ); + vector.y = normals.getY( i ); + vector.z = normals.getZ( i ); + + vector.normalize(); + + normals.setXYZ( i, vector.x, vector.y, vector.z ); + + } + + }; + + }(), + + toNonIndexed: function () { + + if ( this.index === null ) { + + console.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' ); + return this; + + } + + var geometry2 = new BufferGeometry(); + + var indices = this.index.array; + var attributes = this.attributes; + + for ( var name in attributes ) { + + var attribute = attributes[ name ]; + + var array = attribute.array; + var itemSize = attribute.itemSize; + + var array2 = new array.constructor( indices.length * itemSize ); + + var index = 0, index2 = 0; + + for ( var i = 0, l = indices.length; i < l; i ++ ) { + + index = indices[ i ] * itemSize; + + for ( var j = 0; j < itemSize; j ++ ) { + + array2[ index2 ++ ] = array[ index ++ ]; + + } + + } + + geometry2.addAttribute( name, new BufferAttribute( array2, itemSize ) ); + + } + + return geometry2; + + }, + + toJSON: function () { + + var data = { + metadata: { + version: 4.5, + type: 'BufferGeometry', + generator: 'BufferGeometry.toJSON' + } + }; + + // standard BufferGeometry serialization + + data.uuid = this.uuid; + data.type = this.type; + if ( this.name !== '' ) data.name = this.name; + + if ( this.parameters !== undefined ) { + + var parameters = this.parameters; + + for ( var key in parameters ) { + + if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ]; + + } + + return data; + + } + + data.data = { attributes: {} }; + + var index = this.index; + + if ( index !== null ) { + + var array = Array.prototype.slice.call( index.array ); + + data.data.index = { + type: index.array.constructor.name, + array: array + }; + + } + + var attributes = this.attributes; + + for ( var key in attributes ) { + + var attribute = attributes[ key ]; + + var array = Array.prototype.slice.call( attribute.array ); + + data.data.attributes[ key ] = { + itemSize: attribute.itemSize, + type: attribute.array.constructor.name, + array: array, + normalized: attribute.normalized + }; + + } + + var groups = this.groups; + + if ( groups.length > 0 ) { + + data.data.groups = JSON.parse( JSON.stringify( groups ) ); + + } + + var boundingSphere = this.boundingSphere; + + if ( boundingSphere !== null ) { + + data.data.boundingSphere = { + center: boundingSphere.center.toArray(), + radius: boundingSphere.radius + }; + + } + + return data; + + }, + + clone: function () { + + /* + // Handle primitives + + var parameters = this.parameters; + + if ( parameters !== undefined ) { + + var values = []; + + for ( var key in parameters ) { + + values.push( parameters[ key ] ); + + } + + var geometry = Object.create( this.constructor.prototype ); + this.constructor.apply( geometry, values ); + return geometry; + + } + + return new this.constructor().copy( this ); + */ + + return new BufferGeometry().copy( this ); + + }, + + copy: function ( source ) { + + var name, i, l; + + // reset + + this.index = null; + this.attributes = {}; + this.morphAttributes = {}; + this.groups = []; + this.boundingBox = null; + this.boundingSphere = null; + + // name + + this.name = source.name; + + // index + + var index = source.index; + + if ( index !== null ) { + + this.setIndex( index.clone() ); + + } + + // attributes + + var attributes = source.attributes; + + for ( name in attributes ) { + + var attribute = attributes[ name ]; + this.addAttribute( name, attribute.clone() ); + + } + + // morph attributes + + var morphAttributes = source.morphAttributes; + + for ( name in morphAttributes ) { + + var array = []; + var morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes + + for ( i = 0, l = morphAttribute.length; i < l; i ++ ) { + + array.push( morphAttribute[ i ].clone() ); + + } + + this.morphAttributes[ name ] = array; + + } + + // groups + + var groups = source.groups; + + for ( i = 0, l = groups.length; i < l; i ++ ) { + + var group = groups[ i ]; + this.addGroup( group.start, group.count, group.materialIndex ); + + } + + // bounding box + + var boundingBox = source.boundingBox; + + if ( boundingBox !== null ) { + + this.boundingBox = boundingBox.clone(); + + } + + // bounding sphere + + var boundingSphere = source.boundingSphere; + + if ( boundingSphere !== null ) { + + this.boundingSphere = boundingSphere.clone(); + + } + + // draw range + + this.drawRange.start = source.drawRange.start; + this.drawRange.count = source.drawRange.count; + + return this; + + }, + + dispose: function () { + + this.dispatchEvent( { type: 'dispose' } ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + // BoxGeometry + + function BoxGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) { + + Geometry.call( this ); + + this.type = 'BoxGeometry'; + + this.parameters = { + width: width, + height: height, + depth: depth, + widthSegments: widthSegments, + heightSegments: heightSegments, + depthSegments: depthSegments + }; + + this.fromBufferGeometry( new BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) ); + this.mergeVertices(); + + } + + BoxGeometry.prototype = Object.create( Geometry.prototype ); + BoxGeometry.prototype.constructor = BoxGeometry; + + // BoxBufferGeometry + + function BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) { + + BufferGeometry.call( this ); + + this.type = 'BoxBufferGeometry'; + + this.parameters = { + width: width, + height: height, + depth: depth, + widthSegments: widthSegments, + heightSegments: heightSegments, + depthSegments: depthSegments + }; + + var scope = this; + + width = width || 1; + height = height || 1; + depth = depth || 1; + + // segments + + widthSegments = Math.floor( widthSegments ) || 1; + heightSegments = Math.floor( heightSegments ) || 1; + depthSegments = Math.floor( depthSegments ) || 1; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var numberOfVertices = 0; + var groupStart = 0; + + // build each side of the box geometry + + buildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px + buildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx + buildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py + buildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny + buildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz + buildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + function buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) { + + var segmentWidth = width / gridX; + var segmentHeight = height / gridY; + + var widthHalf = width / 2; + var heightHalf = height / 2; + var depthHalf = depth / 2; + + var gridX1 = gridX + 1; + var gridY1 = gridY + 1; + + var vertexCounter = 0; + var groupCount = 0; + + var ix, iy; + + var vector = new Vector3(); + + // generate vertices, normals and uvs + + for ( iy = 0; iy < gridY1; iy ++ ) { + + var y = iy * segmentHeight - heightHalf; + + for ( ix = 0; ix < gridX1; ix ++ ) { + + var x = ix * segmentWidth - widthHalf; + + // set values to correct vector component + + vector[ u ] = x * udir; + vector[ v ] = y * vdir; + vector[ w ] = depthHalf; + + // now apply vector to vertex buffer + + vertices.push( vector.x, vector.y, vector.z ); + + // set values to correct vector component + + vector[ u ] = 0; + vector[ v ] = 0; + vector[ w ] = depth > 0 ? 1 : - 1; + + // now apply vector to normal buffer + + normals.push( vector.x, vector.y, vector.z ); + + // uvs + + uvs.push( ix / gridX ); + uvs.push( 1 - ( iy / gridY ) ); + + // counters + + vertexCounter += 1; + + } + + } + + // indices + + // 1. you need three indices to draw a single face + // 2. a single segment consists of two faces + // 3. so we need to generate six (2*3) indices per segment + + for ( iy = 0; iy < gridY; iy ++ ) { + + for ( ix = 0; ix < gridX; ix ++ ) { + + var a = numberOfVertices + ix + gridX1 * iy; + var b = numberOfVertices + ix + gridX1 * ( iy + 1 ); + var c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 ); + var d = numberOfVertices + ( ix + 1 ) + gridX1 * iy; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + // increase counter + + groupCount += 6; + + } + + } + + // add a group to the geometry. this will ensure multi material support + + scope.addGroup( groupStart, groupCount, materialIndex ); + + // calculate new start value for groups + + groupStart += groupCount; + + // update total number of vertices + + numberOfVertices += vertexCounter; + + } + + } + + BoxBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + BoxBufferGeometry.prototype.constructor = BoxBufferGeometry; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + // PlaneGeometry + + function PlaneGeometry( width, height, widthSegments, heightSegments ) { + + Geometry.call( this ); + + this.type = 'PlaneGeometry'; + + this.parameters = { + width: width, + height: height, + widthSegments: widthSegments, + heightSegments: heightSegments + }; + + this.fromBufferGeometry( new PlaneBufferGeometry( width, height, widthSegments, heightSegments ) ); + this.mergeVertices(); + + } + + PlaneGeometry.prototype = Object.create( Geometry.prototype ); + PlaneGeometry.prototype.constructor = PlaneGeometry; + + // PlaneBufferGeometry + + function PlaneBufferGeometry( width, height, widthSegments, heightSegments ) { + + BufferGeometry.call( this ); + + this.type = 'PlaneBufferGeometry'; + + this.parameters = { + width: width, + height: height, + widthSegments: widthSegments, + heightSegments: heightSegments + }; + + width = width || 1; + height = height || 1; + + var width_half = width / 2; + var height_half = height / 2; + + var gridX = Math.floor( widthSegments ) || 1; + var gridY = Math.floor( heightSegments ) || 1; + + var gridX1 = gridX + 1; + var gridY1 = gridY + 1; + + var segment_width = width / gridX; + var segment_height = height / gridY; + + var ix, iy; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // generate vertices, normals and uvs + + for ( iy = 0; iy < gridY1; iy ++ ) { + + var y = iy * segment_height - height_half; + + for ( ix = 0; ix < gridX1; ix ++ ) { + + var x = ix * segment_width - width_half; + + vertices.push( x, - y, 0 ); + + normals.push( 0, 0, 1 ); + + uvs.push( ix / gridX ); + uvs.push( 1 - ( iy / gridY ) ); + + } + + } + + // indices + + for ( iy = 0; iy < gridY; iy ++ ) { + + for ( ix = 0; ix < gridX; ix ++ ) { + + var a = ix + gridX1 * iy; + var b = ix + gridX1 * ( iy + 1 ); + var c = ( ix + 1 ) + gridX1 * ( iy + 1 ); + var d = ( ix + 1 ) + gridX1 * iy; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + PlaneBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + PlaneBufferGeometry.prototype.constructor = PlaneBufferGeometry; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * map: new THREE.Texture( ), + * + * lightMap: new THREE.Texture( ), + * lightMapIntensity: + * + * aoMap: new THREE.Texture( ), + * aoMapIntensity: + * + * specularMap: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), + * combine: THREE.Multiply, + * reflectivity: , + * refractionRatio: , + * + * depthTest: , + * depthWrite: , + * + * wireframe: , + * wireframeLinewidth: , + * + * skinning: , + * morphTargets: + * } + */ + + function MeshBasicMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshBasicMaterial'; + + this.color = new Color( 0xffffff ); // emissive + + this.map = null; + + this.lightMap = null; + this.lightMapIntensity = 1.0; + + this.aoMap = null; + this.aoMapIntensity = 1.0; + + this.specularMap = null; + + this.alphaMap = null; + + this.envMap = null; + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = 'round'; + this.wireframeLinejoin = 'round'; + + this.skinning = false; + this.morphTargets = false; + + this.lights = false; + + this.setValues( parameters ); + + } + + MeshBasicMaterial.prototype = Object.create( Material.prototype ); + MeshBasicMaterial.prototype.constructor = MeshBasicMaterial; + + MeshBasicMaterial.prototype.isMeshBasicMaterial = true; + + MeshBasicMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + + this.map = source.map; + + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + + this.specularMap = source.specularMap; + + this.alphaMap = source.alphaMap; + + this.envMap = source.envMap; + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + + return this; + + }; + + /** + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * defines: { "label" : "value" }, + * uniforms: { "parameter1": { value: 1.0 }, "parameter2": { value2: 2 } }, + * + * fragmentShader: , + * vertexShader: , + * + * wireframe: , + * wireframeLinewidth: , + * + * lights: , + * + * skinning: , + * morphTargets: , + * morphNormals: + * } + */ + + function ShaderMaterial( parameters ) { + + Material.call( this ); + + this.type = 'ShaderMaterial'; + + this.defines = {}; + this.uniforms = {}; + + this.vertexShader = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}'; + this.fragmentShader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}'; + + this.linewidth = 1; + + this.wireframe = false; + this.wireframeLinewidth = 1; + + this.fog = false; // set to use scene fog + this.lights = false; // set to use scene lights + this.clipping = false; // set to use user-defined clipping planes + + this.skinning = false; // set to use skinning attribute streams + this.morphTargets = false; // set to use morph targets + this.morphNormals = false; // set to use morph normals + + this.extensions = { + derivatives: false, // set to use derivatives + fragDepth: false, // set to use fragment depth values + drawBuffers: false, // set to use draw buffers + shaderTextureLOD: false // set to use shader texture LOD + }; + + // When rendered geometry doesn't include these attributes but the material does, + // use these default values in WebGL. This avoids errors when buffer data is missing. + this.defaultAttributeValues = { + 'color': [ 1, 1, 1 ], + 'uv': [ 0, 0 ], + 'uv2': [ 0, 0 ] + }; + + this.index0AttributeName = undefined; + + if ( parameters !== undefined ) { + + if ( parameters.attributes !== undefined ) { + + console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' ); + + } + + this.setValues( parameters ); + + } + + } + + ShaderMaterial.prototype = Object.create( Material.prototype ); + ShaderMaterial.prototype.constructor = ShaderMaterial; + + ShaderMaterial.prototype.isShaderMaterial = true; + + ShaderMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.fragmentShader = source.fragmentShader; + this.vertexShader = source.vertexShader; + + this.uniforms = UniformsUtils.clone( source.uniforms ); + + this.defines = source.defines; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + + this.lights = source.lights; + this.clipping = source.clipping; + + this.skinning = source.skinning; + + this.morphTargets = source.morphTargets; + this.morphNormals = source.morphNormals; + + this.extensions = source.extensions; + + return this; + + }; + + ShaderMaterial.prototype.toJSON = function ( meta ) { + + var data = Material.prototype.toJSON.call( this, meta ); + + data.uniforms = this.uniforms; + data.vertexShader = this.vertexShader; + data.fragmentShader = this.fragmentShader; + + return data; + + }; + + /** + * @author bhouston / http://clara.io + */ + + function Ray( origin, direction ) { + + this.origin = ( origin !== undefined ) ? origin : new Vector3(); + this.direction = ( direction !== undefined ) ? direction : new Vector3(); + + } + + Object.assign( Ray.prototype, { + + set: function ( origin, direction ) { + + this.origin.copy( origin ); + this.direction.copy( direction ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( ray ) { + + this.origin.copy( ray.origin ); + this.direction.copy( ray.direction ); + + return this; + + }, + + at: function ( t, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + return result.copy( this.direction ).multiplyScalar( t ).add( this.origin ); + + }, + + lookAt: function ( v ) { + + this.direction.copy( v ).sub( this.origin ).normalize(); + + return this; + + }, + + recast: function () { + + var v1 = new Vector3(); + + return function recast( t ) { + + this.origin.copy( this.at( t, v1 ) ); + + return this; + + }; + + }(), + + closestPointToPoint: function ( point, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + result.subVectors( point, this.origin ); + var directionDistance = result.dot( this.direction ); + + if ( directionDistance < 0 ) { + + return result.copy( this.origin ); + + } + + return result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin ); + + }, + + distanceToPoint: function ( point ) { + + return Math.sqrt( this.distanceSqToPoint( point ) ); + + }, + + distanceSqToPoint: function () { + + var v1 = new Vector3(); + + return function distanceSqToPoint( point ) { + + var directionDistance = v1.subVectors( point, this.origin ).dot( this.direction ); + + // point behind the ray + + if ( directionDistance < 0 ) { + + return this.origin.distanceToSquared( point ); + + } + + v1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin ); + + return v1.distanceToSquared( point ); + + }; + + }(), + + distanceSqToSegment: function () { + + var segCenter = new Vector3(); + var segDir = new Vector3(); + var diff = new Vector3(); + + return function distanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) { + + // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteDistRaySegment.h + // It returns the min distance between the ray and the segment + // defined by v0 and v1 + // It can also set two optional targets : + // - The closest point on the ray + // - The closest point on the segment + + segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 ); + segDir.copy( v1 ).sub( v0 ).normalize(); + diff.copy( this.origin ).sub( segCenter ); + + var segExtent = v0.distanceTo( v1 ) * 0.5; + var a01 = - this.direction.dot( segDir ); + var b0 = diff.dot( this.direction ); + var b1 = - diff.dot( segDir ); + var c = diff.lengthSq(); + var det = Math.abs( 1 - a01 * a01 ); + var s0, s1, sqrDist, extDet; + + if ( det > 0 ) { + + // The ray and segment are not parallel. + + s0 = a01 * b1 - b0; + s1 = a01 * b0 - b1; + extDet = segExtent * det; + + if ( s0 >= 0 ) { + + if ( s1 >= - extDet ) { + + if ( s1 <= extDet ) { + + // region 0 + // Minimum at interior points of ray and segment. + + var invDet = 1 / det; + s0 *= invDet; + s1 *= invDet; + sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c; + + } else { + + // region 1 + + s1 = segExtent; + s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); + sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; + + } + + } else { + + // region 5 + + s1 = - segExtent; + s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); + sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; + + } + + } else { + + if ( s1 <= - extDet ) { + + // region 4 + + s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) ); + s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent ); + sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; + + } else if ( s1 <= extDet ) { + + // region 3 + + s0 = 0; + s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent ); + sqrDist = s1 * ( s1 + 2 * b1 ) + c; + + } else { + + // region 2 + + s0 = Math.max( 0, - ( a01 * segExtent + b0 ) ); + s1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent ); + sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; + + } + + } + + } else { + + // Ray and segment are parallel. + + s1 = ( a01 > 0 ) ? - segExtent : segExtent; + s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); + sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; + + } + + if ( optionalPointOnRay ) { + + optionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin ); + + } + + if ( optionalPointOnSegment ) { + + optionalPointOnSegment.copy( segDir ).multiplyScalar( s1 ).add( segCenter ); + + } + + return sqrDist; + + }; + + }(), + + intersectSphere: function () { + + var v1 = new Vector3(); + + return function intersectSphere( sphere, optionalTarget ) { + + v1.subVectors( sphere.center, this.origin ); + var tca = v1.dot( this.direction ); + var d2 = v1.dot( v1 ) - tca * tca; + var radius2 = sphere.radius * sphere.radius; + + if ( d2 > radius2 ) return null; + + var thc = Math.sqrt( radius2 - d2 ); + + // t0 = first intersect point - entrance on front of sphere + var t0 = tca - thc; + + // t1 = second intersect point - exit point on back of sphere + var t1 = tca + thc; + + // test to see if both t0 and t1 are behind the ray - if so, return null + if ( t0 < 0 && t1 < 0 ) return null; + + // test to see if t0 is behind the ray: + // if it is, the ray is inside the sphere, so return the second exit point scaled by t1, + // in order to always return an intersect point that is in front of the ray. + if ( t0 < 0 ) return this.at( t1, optionalTarget ); + + // else t0 is in front of the ray, so return the first collision point scaled by t0 + return this.at( t0, optionalTarget ); + + }; + + }(), + + intersectsSphere: function ( sphere ) { + + return this.distanceToPoint( sphere.center ) <= sphere.radius; + + }, + + distanceToPlane: function ( plane ) { + + var denominator = plane.normal.dot( this.direction ); + + if ( denominator === 0 ) { + + // line is coplanar, return origin + if ( plane.distanceToPoint( this.origin ) === 0 ) { + + return 0; + + } + + // Null is preferable to undefined since undefined means.... it is undefined + + return null; + + } + + var t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator; + + // Return if the ray never intersects the plane + + return t >= 0 ? t : null; + + }, + + intersectPlane: function ( plane, optionalTarget ) { + + var t = this.distanceToPlane( plane ); + + if ( t === null ) { + + return null; + + } + + return this.at( t, optionalTarget ); + + }, + + intersectsPlane: function ( plane ) { + + // check if the ray lies on the plane first + + var distToPoint = plane.distanceToPoint( this.origin ); + + if ( distToPoint === 0 ) { + + return true; + + } + + var denominator = plane.normal.dot( this.direction ); + + if ( denominator * distToPoint < 0 ) { + + return true; + + } + + // ray origin is behind the plane (and is pointing behind it) + + return false; + + }, + + intersectBox: function ( box, optionalTarget ) { + + var tmin, tmax, tymin, tymax, tzmin, tzmax; + + var invdirx = 1 / this.direction.x, + invdiry = 1 / this.direction.y, + invdirz = 1 / this.direction.z; + + var origin = this.origin; + + if ( invdirx >= 0 ) { + + tmin = ( box.min.x - origin.x ) * invdirx; + tmax = ( box.max.x - origin.x ) * invdirx; + + } else { + + tmin = ( box.max.x - origin.x ) * invdirx; + tmax = ( box.min.x - origin.x ) * invdirx; + + } + + if ( invdiry >= 0 ) { + + tymin = ( box.min.y - origin.y ) * invdiry; + tymax = ( box.max.y - origin.y ) * invdiry; + + } else { + + tymin = ( box.max.y - origin.y ) * invdiry; + tymax = ( box.min.y - origin.y ) * invdiry; + + } + + if ( ( tmin > tymax ) || ( tymin > tmax ) ) return null; + + // These lines also handle the case where tmin or tmax is NaN + // (result of 0 * Infinity). x !== x returns true if x is NaN + + if ( tymin > tmin || tmin !== tmin ) tmin = tymin; + + if ( tymax < tmax || tmax !== tmax ) tmax = tymax; + + if ( invdirz >= 0 ) { + + tzmin = ( box.min.z - origin.z ) * invdirz; + tzmax = ( box.max.z - origin.z ) * invdirz; + + } else { + + tzmin = ( box.max.z - origin.z ) * invdirz; + tzmax = ( box.min.z - origin.z ) * invdirz; + + } + + if ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null; + + if ( tzmin > tmin || tmin !== tmin ) tmin = tzmin; + + if ( tzmax < tmax || tmax !== tmax ) tmax = tzmax; + + //return point closest to the ray (positive side) + + if ( tmax < 0 ) return null; + + return this.at( tmin >= 0 ? tmin : tmax, optionalTarget ); + + }, + + intersectsBox: ( function () { + + var v = new Vector3(); + + return function intersectsBox( box ) { + + return this.intersectBox( box, v ) !== null; + + }; + + } )(), + + intersectTriangle: function () { + + // Compute the offset origin, edges, and normal. + var diff = new Vector3(); + var edge1 = new Vector3(); + var edge2 = new Vector3(); + var normal = new Vector3(); + + return function intersectTriangle( a, b, c, backfaceCulling, optionalTarget ) { + + // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h + + edge1.subVectors( b, a ); + edge2.subVectors( c, a ); + normal.crossVectors( edge1, edge2 ); + + // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction, + // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by + // |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2)) + // |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q)) + // |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N) + var DdN = this.direction.dot( normal ); + var sign; + + if ( DdN > 0 ) { + + if ( backfaceCulling ) return null; + sign = 1; + + } else if ( DdN < 0 ) { + + sign = - 1; + DdN = - DdN; + + } else { + + return null; + + } + + diff.subVectors( this.origin, a ); + var DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) ); + + // b1 < 0, no intersection + if ( DdQxE2 < 0 ) { + + return null; + + } + + var DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) ); + + // b2 < 0, no intersection + if ( DdE1xQ < 0 ) { + + return null; + + } + + // b1+b2 > 1, no intersection + if ( DdQxE2 + DdE1xQ > DdN ) { + + return null; + + } + + // Line intersects triangle, check if ray does. + var QdN = - sign * diff.dot( normal ); + + // t < 0, no intersection + if ( QdN < 0 ) { + + return null; + + } + + // Ray intersects triangle. + return this.at( QdN / DdN, optionalTarget ); + + }; + + }(), + + applyMatrix4: function ( matrix4 ) { + + this.origin.applyMatrix4( matrix4 ); + this.direction.transformDirection( matrix4 ); + + return this; + + }, + + equals: function ( ray ) { + + return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction ); + + } + + } ); + + /** + * @author bhouston / http://clara.io + */ + + function Line3( start, end ) { + + this.start = ( start !== undefined ) ? start : new Vector3(); + this.end = ( end !== undefined ) ? end : new Vector3(); + + } + + Object.assign( Line3.prototype, { + + set: function ( start, end ) { + + this.start.copy( start ); + this.end.copy( end ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( line ) { + + this.start.copy( line.start ); + this.end.copy( line.end ); + + return this; + + }, + + getCenter: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return result.addVectors( this.start, this.end ).multiplyScalar( 0.5 ); + + }, + + delta: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return result.subVectors( this.end, this.start ); + + }, + + distanceSq: function () { + + return this.start.distanceToSquared( this.end ); + + }, + + distance: function () { + + return this.start.distanceTo( this.end ); + + }, + + at: function ( t, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + return this.delta( result ).multiplyScalar( t ).add( this.start ); + + }, + + closestPointToPointParameter: function () { + + var startP = new Vector3(); + var startEnd = new Vector3(); + + return function closestPointToPointParameter( point, clampToLine ) { + + startP.subVectors( point, this.start ); + startEnd.subVectors( this.end, this.start ); + + var startEnd2 = startEnd.dot( startEnd ); + var startEnd_startP = startEnd.dot( startP ); + + var t = startEnd_startP / startEnd2; + + if ( clampToLine ) { + + t = _Math.clamp( t, 0, 1 ); + + } + + return t; + + }; + + }(), + + closestPointToPoint: function ( point, clampToLine, optionalTarget ) { + + var t = this.closestPointToPointParameter( point, clampToLine ); + + var result = optionalTarget || new Vector3(); + + return this.delta( result ).multiplyScalar( t ).add( this.start ); + + }, + + applyMatrix4: function ( matrix ) { + + this.start.applyMatrix4( matrix ); + this.end.applyMatrix4( matrix ); + + return this; + + }, + + equals: function ( line ) { + + return line.start.equals( this.start ) && line.end.equals( this.end ); + + } + + } ); + + /** + * @author bhouston / http://clara.io + * @author mrdoob / http://mrdoob.com/ + */ + + function Triangle( a, b, c ) { + + this.a = ( a !== undefined ) ? a : new Vector3(); + this.b = ( b !== undefined ) ? b : new Vector3(); + this.c = ( c !== undefined ) ? c : new Vector3(); + + } + + Object.assign( Triangle, { + + normal: function () { + + var v0 = new Vector3(); + + return function normal( a, b, c, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + + result.subVectors( c, b ); + v0.subVectors( a, b ); + result.cross( v0 ); + + var resultLengthSq = result.lengthSq(); + if ( resultLengthSq > 0 ) { + + return result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) ); + + } + + return result.set( 0, 0, 0 ); + + }; + + }(), + + // static/instance method to calculate barycentric coordinates + // based on: http://www.blackpawn.com/texts/pointinpoly/default.html + barycoordFromPoint: function () { + + var v0 = new Vector3(); + var v1 = new Vector3(); + var v2 = new Vector3(); + + return function barycoordFromPoint( point, a, b, c, optionalTarget ) { + + v0.subVectors( c, a ); + v1.subVectors( b, a ); + v2.subVectors( point, a ); + + var dot00 = v0.dot( v0 ); + var dot01 = v0.dot( v1 ); + var dot02 = v0.dot( v2 ); + var dot11 = v1.dot( v1 ); + var dot12 = v1.dot( v2 ); + + var denom = ( dot00 * dot11 - dot01 * dot01 ); + + var result = optionalTarget || new Vector3(); + + // collinear or singular triangle + if ( denom === 0 ) { + + // arbitrary location outside of triangle? + // not sure if this is the best idea, maybe should be returning undefined + return result.set( - 2, - 1, - 1 ); + + } + + var invDenom = 1 / denom; + var u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom; + var v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom; + + // barycentric coordinates must always sum to 1 + return result.set( 1 - u - v, v, u ); + + }; + + }(), + + containsPoint: function () { + + var v1 = new Vector3(); + + return function containsPoint( point, a, b, c ) { + + var result = Triangle.barycoordFromPoint( point, a, b, c, v1 ); + + return ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 ); + + }; + + }() + + } ); + + Object.assign( Triangle.prototype, { + + set: function ( a, b, c ) { + + this.a.copy( a ); + this.b.copy( b ); + this.c.copy( c ); + + return this; + + }, + + setFromPointsAndIndices: function ( points, i0, i1, i2 ) { + + this.a.copy( points[ i0 ] ); + this.b.copy( points[ i1 ] ); + this.c.copy( points[ i2 ] ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( triangle ) { + + this.a.copy( triangle.a ); + this.b.copy( triangle.b ); + this.c.copy( triangle.c ); + + return this; + + }, + + area: function () { + + var v0 = new Vector3(); + var v1 = new Vector3(); + + return function area() { + + v0.subVectors( this.c, this.b ); + v1.subVectors( this.a, this.b ); + + return v0.cross( v1 ).length() * 0.5; + + }; + + }(), + + midpoint: function ( optionalTarget ) { + + var result = optionalTarget || new Vector3(); + return result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 ); + + }, + + normal: function ( optionalTarget ) { + + return Triangle.normal( this.a, this.b, this.c, optionalTarget ); + + }, + + plane: function ( optionalTarget ) { + + var result = optionalTarget || new Plane(); + + return result.setFromCoplanarPoints( this.a, this.b, this.c ); + + }, + + barycoordFromPoint: function ( point, optionalTarget ) { + + return Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget ); + + }, + + containsPoint: function ( point ) { + + return Triangle.containsPoint( point, this.a, this.b, this.c ); + + }, + + closestPointToPoint: function () { + + var plane = new Plane(); + var edgeList = [ new Line3(), new Line3(), new Line3() ]; + var projectedPoint = new Vector3(); + var closestPoint = new Vector3(); + + return function closestPointToPoint( point, optionalTarget ) { + + var result = optionalTarget || new Vector3(); + var minDistance = Infinity; + + // project the point onto the plane of the triangle + + plane.setFromCoplanarPoints( this.a, this.b, this.c ); + plane.projectPoint( point, projectedPoint ); + + // check if the projection lies within the triangle + + if ( this.containsPoint( projectedPoint ) === true ) { + + // if so, this is the closest point + + result.copy( projectedPoint ); + + } else { + + // if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices + + edgeList[ 0 ].set( this.a, this.b ); + edgeList[ 1 ].set( this.b, this.c ); + edgeList[ 2 ].set( this.c, this.a ); + + for ( var i = 0; i < edgeList.length; i ++ ) { + + edgeList[ i ].closestPointToPoint( projectedPoint, true, closestPoint ); + + var distance = projectedPoint.distanceToSquared( closestPoint ); + + if ( distance < minDistance ) { + + minDistance = distance; + + result.copy( closestPoint ); + + } + + } + + } + + return result; + + }; + + }(), + + equals: function ( triangle ) { + + return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * @author mikael emtinger / http://gomo.se/ + * @author jonobr1 / http://jonobr1.com/ + */ + + function Mesh( geometry, material ) { + + Object3D.call( this ); + + this.type = 'Mesh'; + + this.geometry = geometry !== undefined ? geometry : new BufferGeometry(); + this.material = material !== undefined ? material : new MeshBasicMaterial( { color: Math.random() * 0xffffff } ); + + this.drawMode = TrianglesDrawMode; + + this.updateMorphTargets(); + + } + + Mesh.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Mesh, + + isMesh: true, + + setDrawMode: function ( value ) { + + this.drawMode = value; + + }, + + copy: function ( source ) { + + Object3D.prototype.copy.call( this, source ); + + this.drawMode = source.drawMode; + + if ( source.morphTargetInfluences !== undefined ) { + + this.morphTargetInfluences = source.morphTargetInfluences.slice(); + + } + + if ( source.morphTargetDictionary !== undefined ) { + + this.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary ); + + } + + return this; + + }, + + updateMorphTargets: function () { + + var geometry = this.geometry; + var m, ml, name; + + if ( geometry.isBufferGeometry ) { + + var morphAttributes = geometry.morphAttributes; + var keys = Object.keys( morphAttributes ); + + if ( keys.length > 0 ) { + + var morphAttribute = morphAttributes[ keys[ 0 ] ]; + + if ( morphAttribute !== undefined ) { + + this.morphTargetInfluences = []; + this.morphTargetDictionary = {}; + + for ( m = 0, ml = morphAttribute.length; m < ml; m ++ ) { + + name = morphAttribute[ m ].name || String( m ); + + this.morphTargetInfluences.push( 0 ); + this.morphTargetDictionary[ name ] = m; + + } + + } + + } + + } else { + + var morphTargets = geometry.morphTargets; + + if ( morphTargets !== undefined && morphTargets.length > 0 ) { + + this.morphTargetInfluences = []; + this.morphTargetDictionary = {}; + + for ( m = 0, ml = morphTargets.length; m < ml; m ++ ) { + + name = morphTargets[ m ].name || String( m ); + + this.morphTargetInfluences.push( 0 ); + this.morphTargetDictionary[ name ] = m; + + } + + } + + } + + }, + + raycast: ( function () { + + var inverseMatrix = new Matrix4(); + var ray = new Ray(); + var sphere = new Sphere(); + + var vA = new Vector3(); + var vB = new Vector3(); + var vC = new Vector3(); + + var tempA = new Vector3(); + var tempB = new Vector3(); + var tempC = new Vector3(); + + var uvA = new Vector2(); + var uvB = new Vector2(); + var uvC = new Vector2(); + + var barycoord = new Vector3(); + + var intersectionPoint = new Vector3(); + var intersectionPointWorld = new Vector3(); + + function uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) { + + Triangle.barycoordFromPoint( point, p1, p2, p3, barycoord ); + + uv1.multiplyScalar( barycoord.x ); + uv2.multiplyScalar( barycoord.y ); + uv3.multiplyScalar( barycoord.z ); + + uv1.add( uv2 ).add( uv3 ); + + return uv1.clone(); + + } + + function checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) { + + var intersect; + + if ( material.side === BackSide ) { + + intersect = ray.intersectTriangle( pC, pB, pA, true, point ); + + } else { + + intersect = ray.intersectTriangle( pA, pB, pC, material.side !== DoubleSide, point ); + + } + + if ( intersect === null ) return null; + + intersectionPointWorld.copy( point ); + intersectionPointWorld.applyMatrix4( object.matrixWorld ); + + var distance = raycaster.ray.origin.distanceTo( intersectionPointWorld ); + + if ( distance < raycaster.near || distance > raycaster.far ) return null; + + return { + distance: distance, + point: intersectionPointWorld.clone(), + object: object + }; + + } + + function checkBufferGeometryIntersection( object, raycaster, ray, position, uv, a, b, c ) { + + vA.fromBufferAttribute( position, a ); + vB.fromBufferAttribute( position, b ); + vC.fromBufferAttribute( position, c ); + + var intersection = checkIntersection( object, object.material, raycaster, ray, vA, vB, vC, intersectionPoint ); + + if ( intersection ) { + + if ( uv ) { + + uvA.fromBufferAttribute( uv, a ); + uvB.fromBufferAttribute( uv, b ); + uvC.fromBufferAttribute( uv, c ); + + intersection.uv = uvIntersection( intersectionPoint, vA, vB, vC, uvA, uvB, uvC ); + + } + + intersection.face = new Face3( a, b, c, Triangle.normal( vA, vB, vC ) ); + intersection.faceIndex = a; + + } + + return intersection; + + } + + return function raycast( raycaster, intersects ) { + + var geometry = this.geometry; + var material = this.material; + var matrixWorld = this.matrixWorld; + + if ( material === undefined ) return; + + // Checking boundingSphere distance to ray + + if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); + + sphere.copy( geometry.boundingSphere ); + sphere.applyMatrix4( matrixWorld ); + + if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; + + // + + inverseMatrix.getInverse( matrixWorld ); + ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); + + // Check boundingBox before continuing + + if ( geometry.boundingBox !== null ) { + + if ( ray.intersectsBox( geometry.boundingBox ) === false ) return; + + } + + var intersection; + + if ( geometry.isBufferGeometry ) { + + var a, b, c; + var index = geometry.index; + var position = geometry.attributes.position; + var uv = geometry.attributes.uv; + var i, l; + + if ( index !== null ) { + + // indexed buffer geometry + + for ( i = 0, l = index.count; i < l; i += 3 ) { + + a = index.getX( i ); + b = index.getX( i + 1 ); + c = index.getX( i + 2 ); + + intersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c ); + + if ( intersection ) { + + intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics + intersects.push( intersection ); + + } + + } + + } else if ( position !== undefined ) { + + // non-indexed buffer geometry + + for ( i = 0, l = position.count; i < l; i += 3 ) { + + a = i; + b = i + 1; + c = i + 2; + + intersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c ); + + if ( intersection ) { + + intersection.index = a; // triangle number in positions buffer semantics + intersects.push( intersection ); + + } + + } + + } + + } else if ( geometry.isGeometry ) { + + var fvA, fvB, fvC; + var isMultiMaterial = Array.isArray( material ); + + var vertices = geometry.vertices; + var faces = geometry.faces; + var uvs; + + var faceVertexUvs = geometry.faceVertexUvs[ 0 ]; + if ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs; + + for ( var f = 0, fl = faces.length; f < fl; f ++ ) { + + var face = faces[ f ]; + var faceMaterial = isMultiMaterial ? material[ face.materialIndex ] : material; + + if ( faceMaterial === undefined ) continue; + + fvA = vertices[ face.a ]; + fvB = vertices[ face.b ]; + fvC = vertices[ face.c ]; + + if ( faceMaterial.morphTargets === true ) { + + var morphTargets = geometry.morphTargets; + var morphInfluences = this.morphTargetInfluences; + + vA.set( 0, 0, 0 ); + vB.set( 0, 0, 0 ); + vC.set( 0, 0, 0 ); + + for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) { + + var influence = morphInfluences[ t ]; + + if ( influence === 0 ) continue; + + var targets = morphTargets[ t ].vertices; + + vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence ); + vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence ); + vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence ); + + } + + vA.add( fvA ); + vB.add( fvB ); + vC.add( fvC ); + + fvA = vA; + fvB = vB; + fvC = vC; + + } + + intersection = checkIntersection( this, faceMaterial, raycaster, ray, fvA, fvB, fvC, intersectionPoint ); + + if ( intersection ) { + + if ( uvs && uvs[ f ] ) { + + var uvs_f = uvs[ f ]; + uvA.copy( uvs_f[ 0 ] ); + uvB.copy( uvs_f[ 1 ] ); + uvC.copy( uvs_f[ 2 ] ); + + intersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC ); + + } + + intersection.face = face; + intersection.faceIndex = f; + intersects.push( intersection ); + + } + + } + + } + + }; + + }() ), + + clone: function () { + + return new this.constructor( this.geometry, this.material ).copy( this ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLBackground( renderer, state, geometries, premultipliedAlpha ) { + + var clearColor = new Color( 0x000000 ); + var clearAlpha = 0; + + var planeCamera, planeMesh; + var boxMesh; + + function render( renderList, scene, camera, forceClear ) { + + var background = scene.background; + + if ( background === null ) { + + setClear( clearColor, clearAlpha ); + + } else if ( background && background.isColor ) { + + setClear( background, 1 ); + forceClear = true; + + } + + if ( renderer.autoClear || forceClear ) { + + renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil ); + + } + + if ( background && background.isCubeTexture ) { + + if ( boxMesh === undefined ) { + + boxMesh = new Mesh( + new BoxBufferGeometry( 1, 1, 1 ), + new ShaderMaterial( { + uniforms: ShaderLib.cube.uniforms, + vertexShader: ShaderLib.cube.vertexShader, + fragmentShader: ShaderLib.cube.fragmentShader, + side: BackSide, + depthTest: true, + depthWrite: false, + fog: false + } ) + ); + + boxMesh.geometry.removeAttribute( 'normal' ); + boxMesh.geometry.removeAttribute( 'uv' ); + + boxMesh.onBeforeRender = function ( renderer, scene, camera ) { + + this.matrixWorld.copyPosition( camera.matrixWorld ); + + }; + + geometries.update( boxMesh.geometry ); + + } + + boxMesh.material.uniforms.tCube.value = background; + + renderList.push( boxMesh, boxMesh.geometry, boxMesh.material, 0, null ); + + } else if ( background && background.isTexture ) { + + if ( planeCamera === undefined ) { + + planeCamera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 ); + + planeMesh = new Mesh( + new PlaneBufferGeometry( 2, 2 ), + new MeshBasicMaterial( { depthTest: false, depthWrite: false, fog: false } ) + ); + + geometries.update( planeMesh.geometry ); + + } + + planeMesh.material.map = background; + + // TODO Push this to renderList + + renderer.renderBufferDirect( planeCamera, null, planeMesh.geometry, planeMesh.material, planeMesh, null ); + + } + + } + + function setClear( color, alpha ) { + + state.buffers.color.setClear( color.r, color.g, color.b, alpha, premultipliedAlpha ); + + } + + return { + + getClearColor: function () { + + return clearColor; + + }, + setClearColor: function ( color, alpha ) { + + clearColor.set( color ); + clearAlpha = alpha !== undefined ? alpha : 1; + setClear( clearColor, clearAlpha ); + + }, + getClearAlpha: function () { + + return clearAlpha; + + }, + setClearAlpha: function ( alpha ) { + + clearAlpha = alpha; + setClear( clearColor, clearAlpha ); + + }, + render: render + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function painterSortStable( a, b ) { + + if ( a.renderOrder !== b.renderOrder ) { + + return a.renderOrder - b.renderOrder; + + } else if ( a.program && b.program && a.program !== b.program ) { + + return a.program.id - b.program.id; + + } else if ( a.material.id !== b.material.id ) { + + return a.material.id - b.material.id; + + } else if ( a.z !== b.z ) { + + return a.z - b.z; + + } else { + + return a.id - b.id; + + } + + } + + function reversePainterSortStable( a, b ) { + + if ( a.renderOrder !== b.renderOrder ) { + + return a.renderOrder - b.renderOrder; + + } if ( a.z !== b.z ) { + + return b.z - a.z; + + } else { + + return a.id - b.id; + + } + + } + + function WebGLRenderList() { + + var renderItems = []; + var renderItemsIndex = 0; + + var opaque = []; + var transparent = []; + + function init() { + + renderItemsIndex = 0; + + opaque.length = 0; + transparent.length = 0; + + } + + function push( object, geometry, material, z, group ) { + + var renderItem = renderItems[ renderItemsIndex ]; + + if ( renderItem === undefined ) { + + renderItem = { + id: object.id, + object: object, + geometry: geometry, + material: material, + program: material.program, + renderOrder: object.renderOrder, + z: z, + group: group + }; + + renderItems[ renderItemsIndex ] = renderItem; + + } else { + + renderItem.id = object.id; + renderItem.object = object; + renderItem.geometry = geometry; + renderItem.material = material; + renderItem.program = material.program; + renderItem.renderOrder = object.renderOrder; + renderItem.z = z; + renderItem.group = group; + + } + + ( material.transparent === true ? transparent : opaque ).push( renderItem ); + + renderItemsIndex ++; + + } + + function sort() { + + if ( opaque.length > 1 ) opaque.sort( painterSortStable ); + if ( transparent.length > 1 ) transparent.sort( reversePainterSortStable ); + + } + + return { + opaque: opaque, + transparent: transparent, + + init: init, + push: push, + + sort: sort + }; + + } + + function WebGLRenderLists() { + + var lists = {}; + + function get( scene, camera ) { + + var hash = scene.id + ',' + camera.id; + var list = lists[ hash ]; + + if ( list === undefined ) { + + // console.log( 'THREE.WebGLRenderLists:', hash ); + + list = new WebGLRenderList(); + lists[ hash ] = list; + + } + + return list; + + } + + function dispose() { + + lists = {}; + + } + + return { + get: get, + dispose: dispose + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function absNumericalSort( a, b ) { + + return Math.abs( b[ 1 ] ) - Math.abs( a[ 1 ] ); + + } + + function WebGLMorphtargets( gl ) { + + var influencesList = {}; + var morphInfluences = new Float32Array( 8 ); + + function update( object, geometry, material, program ) { + + var objectInfluences = object.morphTargetInfluences; + + var length = objectInfluences.length; + + var influences = influencesList[ geometry.id ]; + + if ( influences === undefined ) { + + // initialise list + + influences = []; + + for ( var i = 0; i < length; i ++ ) { + + influences[ i ] = [ i, 0 ]; + + } + + influencesList[ geometry.id ] = influences; + + } + + var morphTargets = material.morphTargets && geometry.morphAttributes.position; + var morphNormals = material.morphNormals && geometry.morphAttributes.normal; + + // Remove current morphAttributes + + for ( var i = 0; i < length; i ++ ) { + + var influence = influences[ i ]; + + if ( influence[ 1 ] !== 0 ) { + + if ( morphTargets ) geometry.removeAttribute( 'morphTarget' + i ); + if ( morphNormals ) geometry.removeAttribute( 'morphNormal' + i ); + + } + + } + + // Collect influences + + for ( var i = 0; i < length; i ++ ) { + + var influence = influences[ i ]; + + influence[ 0 ] = i; + influence[ 1 ] = objectInfluences[ i ]; + + } + + influences.sort( absNumericalSort ); + + // Add morphAttributes + + for ( var i = 0; i < 8; i ++ ) { + + var influence = influences[ i ]; + + if ( influence ) { + + var index = influence[ 0 ]; + var value = influence[ 1 ]; + + if ( value ) { + + if ( morphTargets ) geometry.addAttribute( 'morphTarget' + i, morphTargets[ index ] ); + if ( morphNormals ) geometry.addAttribute( 'morphNormal' + i, morphNormals[ index ] ); + + morphInfluences[ i ] = value; + continue; + + } + + } + + morphInfluences[ i ] = 0; + + } + + program.getUniforms().setValue( gl, 'morphTargetInfluences', morphInfluences ); + + } + + return { + + update: update + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLIndexedBufferRenderer( gl, extensions, infoRender ) { + + var mode; + + function setMode( value ) { + + mode = value; + + } + + var type, bytesPerElement; + + function setIndex( value ) { + + type = value.type; + bytesPerElement = value.bytesPerElement; + + } + + function render( start, count ) { + + gl.drawElements( mode, count, type, start * bytesPerElement ); + + infoRender.calls ++; + infoRender.vertices += count; + + if ( mode === gl.TRIANGLES ) infoRender.faces += count / 3; + else if ( mode === gl.POINTS ) infoRender.points += count; + + } + + function renderInstances( geometry, start, count ) { + + var extension = extensions.get( 'ANGLE_instanced_arrays' ); + + if ( extension === null ) { + + console.error( 'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); + return; + + } + + extension.drawElementsInstancedANGLE( mode, count, type, start * bytesPerElement, geometry.maxInstancedCount ); + + infoRender.calls ++; + infoRender.vertices += count * geometry.maxInstancedCount; + + if ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3; + else if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count; + + } + + // + + this.setMode = setMode; + this.setIndex = setIndex; + this.render = render; + this.renderInstances = renderInstances; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLBufferRenderer( gl, extensions, infoRender ) { + + var mode; + + function setMode( value ) { + + mode = value; + + } + + function render( start, count ) { + + gl.drawArrays( mode, start, count ); + + infoRender.calls ++; + infoRender.vertices += count; + + if ( mode === gl.TRIANGLES ) infoRender.faces += count / 3; + else if ( mode === gl.POINTS ) infoRender.points += count; + + } + + function renderInstances( geometry, start, count ) { + + var extension = extensions.get( 'ANGLE_instanced_arrays' ); + + if ( extension === null ) { + + console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); + return; + + } + + var position = geometry.attributes.position; + + if ( position.isInterleavedBufferAttribute ) { + + count = position.data.count; + + extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount ); + + } else { + + extension.drawArraysInstancedANGLE( mode, start, count, geometry.maxInstancedCount ); + + } + + infoRender.calls ++; + infoRender.vertices += count * geometry.maxInstancedCount; + + if ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3; + else if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count; + + } + + // + + this.setMode = setMode; + this.render = render; + this.renderInstances = renderInstances; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLGeometries( gl, attributes, infoMemory ) { + + var geometries = {}; + var wireframeAttributes = {}; + + function onGeometryDispose( event ) { + + var geometry = event.target; + var buffergeometry = geometries[ geometry.id ]; + + if ( buffergeometry.index !== null ) { + + attributes.remove( buffergeometry.index ); + + } + + for ( var name in buffergeometry.attributes ) { + + attributes.remove( buffergeometry.attributes[ name ] ); + + } + + geometry.removeEventListener( 'dispose', onGeometryDispose ); + + delete geometries[ geometry.id ]; + + // TODO Remove duplicate code + + var attribute = wireframeAttributes[ geometry.id ]; + + if ( attribute ) { + + attributes.remove( attribute ); + delete wireframeAttributes[ geometry.id ]; + + } + + attribute = wireframeAttributes[ buffergeometry.id ]; + + if ( attribute ) { + + attributes.remove( attribute ); + delete wireframeAttributes[ buffergeometry.id ]; + + } + + // + + infoMemory.geometries --; + + } + + function get( object, geometry ) { + + var buffergeometry = geometries[ geometry.id ]; + + if ( buffergeometry ) return buffergeometry; + + geometry.addEventListener( 'dispose', onGeometryDispose ); + + if ( geometry.isBufferGeometry ) { + + buffergeometry = geometry; + + } else if ( geometry.isGeometry ) { + + if ( geometry._bufferGeometry === undefined ) { + + geometry._bufferGeometry = new BufferGeometry().setFromObject( object ); + + } + + buffergeometry = geometry._bufferGeometry; + + } + + geometries[ geometry.id ] = buffergeometry; + + infoMemory.geometries ++; + + return buffergeometry; + + } + + function update( geometry ) { + + var index = geometry.index; + var geometryAttributes = geometry.attributes; + + if ( index !== null ) { + + attributes.update( index, gl.ELEMENT_ARRAY_BUFFER ); + + } + + for ( var name in geometryAttributes ) { + + attributes.update( geometryAttributes[ name ], gl.ARRAY_BUFFER ); + + } + + // morph targets + + var morphAttributes = geometry.morphAttributes; + + for ( var name in morphAttributes ) { + + var array = morphAttributes[ name ]; + + for ( var i = 0, l = array.length; i < l; i ++ ) { + + attributes.update( array[ i ], gl.ARRAY_BUFFER ); + + } + + } + + } + + function getWireframeAttribute( geometry ) { + + var attribute = wireframeAttributes[ geometry.id ]; + + if ( attribute ) return attribute; + + var indices = []; + + var geometryIndex = geometry.index; + var geometryAttributes = geometry.attributes; + + // console.time( 'wireframe' ); + + if ( geometryIndex !== null ) { + + var array = geometryIndex.array; + + for ( var i = 0, l = array.length; i < l; i += 3 ) { + + var a = array[ i + 0 ]; + var b = array[ i + 1 ]; + var c = array[ i + 2 ]; + + indices.push( a, b, b, c, c, a ); + + } + + } else { + + var array = geometryAttributes.position.array; + + for ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) { + + var a = i + 0; + var b = i + 1; + var c = i + 2; + + indices.push( a, b, b, c, c, a ); + + } + + } + + // console.timeEnd( 'wireframe' ); + + attribute = new ( arrayMax( indices ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 ); + + attributes.update( attribute, gl.ELEMENT_ARRAY_BUFFER ); + + wireframeAttributes[ geometry.id ] = attribute; + + return attribute; + + } + + return { + + get: get, + update: update, + + getWireframeAttribute: getWireframeAttribute + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function UniformsCache() { + + var lights = {}; + + return { + + get: function ( light ) { + + if ( lights[ light.id ] !== undefined ) { + + return lights[ light.id ]; + + } + + var uniforms; + + switch ( light.type ) { + + case 'DirectionalLight': + uniforms = { + direction: new Vector3(), + color: new Color(), + + shadow: false, + shadowBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2() + }; + break; + + case 'SpotLight': + uniforms = { + position: new Vector3(), + direction: new Vector3(), + color: new Color(), + distance: 0, + coneCos: 0, + penumbraCos: 0, + decay: 0, + + shadow: false, + shadowBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2() + }; + break; + + case 'PointLight': + uniforms = { + position: new Vector3(), + color: new Color(), + distance: 0, + decay: 0, + + shadow: false, + shadowBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2(), + shadowCameraNear: 1, + shadowCameraFar: 1000 + }; + break; + + case 'HemisphereLight': + uniforms = { + direction: new Vector3(), + skyColor: new Color(), + groundColor: new Color() + }; + break; + + case 'RectAreaLight': + uniforms = { + color: new Color(), + position: new Vector3(), + halfWidth: new Vector3(), + halfHeight: new Vector3() + // TODO (abelnation): set RectAreaLight shadow uniforms + }; + break; + + } + + lights[ light.id ] = uniforms; + + return uniforms; + + } + + }; + + } + + function WebGLLights() { + + var cache = new UniformsCache(); + + var state = { + + hash: '', + + ambient: [ 0, 0, 0 ], + directional: [], + directionalShadowMap: [], + directionalShadowMatrix: [], + spot: [], + spotShadowMap: [], + spotShadowMatrix: [], + rectArea: [], + point: [], + pointShadowMap: [], + pointShadowMatrix: [], + hemi: [] + + }; + + var vector3 = new Vector3(); + var matrix4 = new Matrix4(); + var matrix42 = new Matrix4(); + + function setup( lights, shadows, camera ) { + + var r = 0, g = 0, b = 0; + + var directionalLength = 0; + var pointLength = 0; + var spotLength = 0; + var rectAreaLength = 0; + var hemiLength = 0; + + var viewMatrix = camera.matrixWorldInverse; + + for ( var i = 0, l = lights.length; i < l; i ++ ) { + + var light = lights[ i ]; + + var color = light.color; + var intensity = light.intensity; + var distance = light.distance; + + var shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null; + + if ( light.isAmbientLight ) { + + r += color.r * intensity; + g += color.g * intensity; + b += color.b * intensity; + + } else if ( light.isDirectionalLight ) { + + var uniforms = cache.get( light ); + + uniforms.color.copy( light.color ).multiplyScalar( light.intensity ); + uniforms.direction.setFromMatrixPosition( light.matrixWorld ); + vector3.setFromMatrixPosition( light.target.matrixWorld ); + uniforms.direction.sub( vector3 ); + uniforms.direction.transformDirection( viewMatrix ); + + uniforms.shadow = light.castShadow; + + if ( light.castShadow ) { + + var shadow = light.shadow; + + uniforms.shadowBias = shadow.bias; + uniforms.shadowRadius = shadow.radius; + uniforms.shadowMapSize = shadow.mapSize; + + } + + state.directionalShadowMap[ directionalLength ] = shadowMap; + state.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix; + state.directional[ directionalLength ] = uniforms; + + directionalLength ++; + + } else if ( light.isSpotLight ) { + + var uniforms = cache.get( light ); + + uniforms.position.setFromMatrixPosition( light.matrixWorld ); + uniforms.position.applyMatrix4( viewMatrix ); + + uniforms.color.copy( color ).multiplyScalar( intensity ); + uniforms.distance = distance; + + uniforms.direction.setFromMatrixPosition( light.matrixWorld ); + vector3.setFromMatrixPosition( light.target.matrixWorld ); + uniforms.direction.sub( vector3 ); + uniforms.direction.transformDirection( viewMatrix ); + + uniforms.coneCos = Math.cos( light.angle ); + uniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) ); + uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay; + + uniforms.shadow = light.castShadow; + + if ( light.castShadow ) { + + var shadow = light.shadow; + + uniforms.shadowBias = shadow.bias; + uniforms.shadowRadius = shadow.radius; + uniforms.shadowMapSize = shadow.mapSize; + + } + + state.spotShadowMap[ spotLength ] = shadowMap; + state.spotShadowMatrix[ spotLength ] = light.shadow.matrix; + state.spot[ spotLength ] = uniforms; + + spotLength ++; + + } else if ( light.isRectAreaLight ) { + + var uniforms = cache.get( light ); + + // (a) intensity controls irradiance of entire light + uniforms.color + .copy( color ) + .multiplyScalar( intensity / ( light.width * light.height ) ); + + // (b) intensity controls the radiance per light area + // uniforms.color.copy( color ).multiplyScalar( intensity ); + + uniforms.position.setFromMatrixPosition( light.matrixWorld ); + uniforms.position.applyMatrix4( viewMatrix ); + + // extract local rotation of light to derive width/height half vectors + matrix42.identity(); + matrix4.copy( light.matrixWorld ); + matrix4.premultiply( viewMatrix ); + matrix42.extractRotation( matrix4 ); + + uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 ); + uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 ); + + uniforms.halfWidth.applyMatrix4( matrix42 ); + uniforms.halfHeight.applyMatrix4( matrix42 ); + + // TODO (abelnation): RectAreaLight distance? + // uniforms.distance = distance; + + state.rectArea[ rectAreaLength ] = uniforms; + + rectAreaLength ++; + + } else if ( light.isPointLight ) { + + var uniforms = cache.get( light ); + + uniforms.position.setFromMatrixPosition( light.matrixWorld ); + uniforms.position.applyMatrix4( viewMatrix ); + + uniforms.color.copy( light.color ).multiplyScalar( light.intensity ); + uniforms.distance = light.distance; + uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay; + + uniforms.shadow = light.castShadow; + + if ( light.castShadow ) { + + var shadow = light.shadow; + + uniforms.shadowBias = shadow.bias; + uniforms.shadowRadius = shadow.radius; + uniforms.shadowMapSize = shadow.mapSize; + uniforms.shadowCameraNear = shadow.camera.near; + uniforms.shadowCameraFar = shadow.camera.far; + + } + + state.pointShadowMap[ pointLength ] = shadowMap; + state.pointShadowMatrix[ pointLength ] = light.shadow.matrix; + state.point[ pointLength ] = uniforms; + + pointLength ++; + + } else if ( light.isHemisphereLight ) { + + var uniforms = cache.get( light ); + + uniforms.direction.setFromMatrixPosition( light.matrixWorld ); + uniforms.direction.transformDirection( viewMatrix ); + uniforms.direction.normalize(); + + uniforms.skyColor.copy( light.color ).multiplyScalar( intensity ); + uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity ); + + state.hemi[ hemiLength ] = uniforms; + + hemiLength ++; + + } + + } + + state.ambient[ 0 ] = r; + state.ambient[ 1 ] = g; + state.ambient[ 2 ] = b; + + state.directional.length = directionalLength; + state.spot.length = spotLength; + state.rectArea.length = rectAreaLength; + state.point.length = pointLength; + state.hemi.length = hemiLength; + + // TODO (sam-g-steel) why aren't we using join + state.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + rectAreaLength + ',' + hemiLength + ',' + shadows.length; + + } + + return { + setup: setup, + state: state + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLObjects( geometries, infoRender ) { + + var updateList = {}; + + function update( object ) { + + var frame = infoRender.frame; + + var geometry = object.geometry; + var buffergeometry = geometries.get( object, geometry ); + + // Update once per frame + + if ( updateList[ buffergeometry.id ] !== frame ) { + + if ( geometry.isGeometry ) { + + buffergeometry.updateFromObject( object ); + + } + + geometries.update( buffergeometry ); + + updateList[ buffergeometry.id ] = frame; + + } + + return buffergeometry; + + } + + function clear() { + + updateList = {}; + + } + + return { + + update: update, + clear: clear + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function addLineNumbers( string ) { + + var lines = string.split( '\n' ); + + for ( var i = 0; i < lines.length; i ++ ) { + + lines[ i ] = ( i + 1 ) + ': ' + lines[ i ]; + + } + + return lines.join( '\n' ); + + } + + function WebGLShader( gl, type, string ) { + + var shader = gl.createShader( type ); + + gl.shaderSource( shader, string ); + gl.compileShader( shader ); + + if ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) { + + console.error( 'THREE.WebGLShader: Shader couldn\'t compile.' ); + + } + + if ( gl.getShaderInfoLog( shader ) !== '' ) { + + console.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) ); + + } + + // --enable-privileged-webgl-extension + // console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) ); + + return shader; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + var programIdCount = 0; + + function getEncodingComponents( encoding ) { + + switch ( encoding ) { + + case LinearEncoding: + return [ 'Linear', '( value )' ]; + case sRGBEncoding: + return [ 'sRGB', '( value )' ]; + case RGBEEncoding: + return [ 'RGBE', '( value )' ]; + case RGBM7Encoding: + return [ 'RGBM', '( value, 7.0 )' ]; + case RGBM16Encoding: + return [ 'RGBM', '( value, 16.0 )' ]; + case RGBDEncoding: + return [ 'RGBD', '( value, 256.0 )' ]; + case GammaEncoding: + return [ 'Gamma', '( value, float( GAMMA_FACTOR ) )' ]; + default: + throw new Error( 'unsupported encoding: ' + encoding ); + + } + + } + + function getTexelDecodingFunction( functionName, encoding ) { + + var components = getEncodingComponents( encoding ); + return 'vec4 ' + functionName + '( vec4 value ) { return ' + components[ 0 ] + 'ToLinear' + components[ 1 ] + '; }'; + + } + + function getTexelEncodingFunction( functionName, encoding ) { + + var components = getEncodingComponents( encoding ); + return 'vec4 ' + functionName + '( vec4 value ) { return LinearTo' + components[ 0 ] + components[ 1 ] + '; }'; + + } + + function getToneMappingFunction( functionName, toneMapping ) { + + var toneMappingName; + + switch ( toneMapping ) { + + case LinearToneMapping: + toneMappingName = 'Linear'; + break; + + case ReinhardToneMapping: + toneMappingName = 'Reinhard'; + break; + + case Uncharted2ToneMapping: + toneMappingName = 'Uncharted2'; + break; + + case CineonToneMapping: + toneMappingName = 'OptimizedCineon'; + break; + + default: + throw new Error( 'unsupported toneMapping: ' + toneMapping ); + + } + + return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }'; + + } + + function generateExtensions( extensions, parameters, rendererExtensions ) { + + extensions = extensions || {}; + + var chunks = [ + ( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '', + ( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '', + ( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '', + ( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : '' + ]; + + return chunks.filter( filterEmptyLine ).join( '\n' ); + + } + + function generateDefines( defines ) { + + var chunks = []; + + for ( var name in defines ) { + + var value = defines[ name ]; + + if ( value === false ) continue; + + chunks.push( '#define ' + name + ' ' + value ); + + } + + return chunks.join( '\n' ); + + } + + function fetchAttributeLocations( gl, program ) { + + var attributes = {}; + + var n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES ); + + for ( var i = 0; i < n; i ++ ) { + + var info = gl.getActiveAttrib( program, i ); + var name = info.name; + + // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i ); + + attributes[ name ] = gl.getAttribLocation( program, name ); + + } + + return attributes; + + } + + function filterEmptyLine( string ) { + + return string !== ''; + + } + + function replaceLightNums( string, parameters ) { + + return string + .replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights ) + .replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights ) + .replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights ) + .replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights ) + .replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights ); + + } + + function parseIncludes( string ) { + + var pattern = /^[ \t]*#include +<([\w\d.]+)>/gm; + + function replace( match, include ) { + + var replace = ShaderChunk[ include ]; + + if ( replace === undefined ) { + + throw new Error( 'Can not resolve #include <' + include + '>' ); + + } + + return parseIncludes( replace ); + + } + + return string.replace( pattern, replace ); + + } + + function unrollLoops( string ) { + + var pattern = /for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g; + + function replace( match, start, end, snippet ) { + + var unroll = ''; + + for ( var i = parseInt( start ); i < parseInt( end ); i ++ ) { + + unroll += snippet.replace( /\[ i \]/g, '[ ' + i + ' ]' ); + + } + + return unroll; + + } + + return string.replace( pattern, replace ); + + } + + function WebGLProgram( renderer, extensions, code, material, shader, parameters ) { + + var gl = renderer.context; + + var defines = material.defines; + + var vertexShader = shader.vertexShader; + var fragmentShader = shader.fragmentShader; + + var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC'; + + if ( parameters.shadowMapType === PCFShadowMap ) { + + shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF'; + + } else if ( parameters.shadowMapType === PCFSoftShadowMap ) { + + shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT'; + + } + + var envMapTypeDefine = 'ENVMAP_TYPE_CUBE'; + var envMapModeDefine = 'ENVMAP_MODE_REFLECTION'; + var envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'; + + if ( parameters.envMap ) { + + switch ( material.envMap.mapping ) { + + case CubeReflectionMapping: + case CubeRefractionMapping: + envMapTypeDefine = 'ENVMAP_TYPE_CUBE'; + break; + + case CubeUVReflectionMapping: + case CubeUVRefractionMapping: + envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV'; + break; + + case EquirectangularReflectionMapping: + case EquirectangularRefractionMapping: + envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC'; + break; + + case SphericalReflectionMapping: + envMapTypeDefine = 'ENVMAP_TYPE_SPHERE'; + break; + + } + + switch ( material.envMap.mapping ) { + + case CubeRefractionMapping: + case EquirectangularRefractionMapping: + envMapModeDefine = 'ENVMAP_MODE_REFRACTION'; + break; + + } + + switch ( material.combine ) { + + case MultiplyOperation: + envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'; + break; + + case MixOperation: + envMapBlendingDefine = 'ENVMAP_BLENDING_MIX'; + break; + + case AddOperation: + envMapBlendingDefine = 'ENVMAP_BLENDING_ADD'; + break; + + } + + } + + var gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0; + + // console.log( 'building new program ' ); + + // + + var customExtensions = generateExtensions( material.extensions, parameters, extensions ); + + var customDefines = generateDefines( defines ); + + // + + var program = gl.createProgram(); + + var prefixVertex, prefixFragment; + + if ( material.isRawShaderMaterial ) { + + prefixVertex = [ + + customDefines + + ].filter( filterEmptyLine ).join( '\n' ); + + if ( prefixVertex.length > 0 ) { + + prefixVertex += '\n'; + + } + + prefixFragment = [ + + customExtensions, + customDefines + + ].filter( filterEmptyLine ).join( '\n' ); + + if ( prefixFragment.length > 0 ) { + + prefixFragment += '\n'; + + } + + } else { + + prefixVertex = [ + + 'precision ' + parameters.precision + ' float;', + 'precision ' + parameters.precision + ' int;', + + '#define SHADER_NAME ' + shader.name, + + customDefines, + + parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '', + + '#define GAMMA_FACTOR ' + gammaFactorDefine, + + '#define MAX_BONES ' + parameters.maxBones, + ( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '', + ( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '', + + parameters.map ? '#define USE_MAP' : '', + parameters.envMap ? '#define USE_ENVMAP' : '', + parameters.envMap ? '#define ' + envMapModeDefine : '', + parameters.lightMap ? '#define USE_LIGHTMAP' : '', + parameters.aoMap ? '#define USE_AOMAP' : '', + parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '', + parameters.bumpMap ? '#define USE_BUMPMAP' : '', + parameters.normalMap ? '#define USE_NORMALMAP' : '', + parameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '', + parameters.specularMap ? '#define USE_SPECULARMAP' : '', + parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '', + parameters.metalnessMap ? '#define USE_METALNESSMAP' : '', + parameters.alphaMap ? '#define USE_ALPHAMAP' : '', + parameters.vertexColors ? '#define USE_COLOR' : '', + + parameters.flatShading ? '#define FLAT_SHADED' : '', + + parameters.skinning ? '#define USE_SKINNING' : '', + parameters.useVertexTexture ? '#define BONE_TEXTURE' : '', + + parameters.morphTargets ? '#define USE_MORPHTARGETS' : '', + parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '', + parameters.doubleSided ? '#define DOUBLE_SIDED' : '', + parameters.flipSided ? '#define FLIP_SIDED' : '', + + '#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes, + + parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '', + parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '', + + parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '', + + parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '', + parameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '', + + 'uniform mat4 modelMatrix;', + 'uniform mat4 modelViewMatrix;', + 'uniform mat4 projectionMatrix;', + 'uniform mat4 viewMatrix;', + 'uniform mat3 normalMatrix;', + 'uniform vec3 cameraPosition;', + + 'attribute vec3 position;', + 'attribute vec3 normal;', + 'attribute vec2 uv;', + + '#ifdef USE_COLOR', + + ' attribute vec3 color;', + + '#endif', + + '#ifdef USE_MORPHTARGETS', + + ' attribute vec3 morphTarget0;', + ' attribute vec3 morphTarget1;', + ' attribute vec3 morphTarget2;', + ' attribute vec3 morphTarget3;', + + ' #ifdef USE_MORPHNORMALS', + + ' attribute vec3 morphNormal0;', + ' attribute vec3 morphNormal1;', + ' attribute vec3 morphNormal2;', + ' attribute vec3 morphNormal3;', + + ' #else', + + ' attribute vec3 morphTarget4;', + ' attribute vec3 morphTarget5;', + ' attribute vec3 morphTarget6;', + ' attribute vec3 morphTarget7;', + + ' #endif', + + '#endif', + + '#ifdef USE_SKINNING', + + ' attribute vec4 skinIndex;', + ' attribute vec4 skinWeight;', + + '#endif', + + '\n' + + ].filter( filterEmptyLine ).join( '\n' ); + + prefixFragment = [ + + customExtensions, + + 'precision ' + parameters.precision + ' float;', + 'precision ' + parameters.precision + ' int;', + + '#define SHADER_NAME ' + shader.name, + + customDefines, + + parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '', + + '#define GAMMA_FACTOR ' + gammaFactorDefine, + + ( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '', + ( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '', + + parameters.map ? '#define USE_MAP' : '', + parameters.envMap ? '#define USE_ENVMAP' : '', + parameters.envMap ? '#define ' + envMapTypeDefine : '', + parameters.envMap ? '#define ' + envMapModeDefine : '', + parameters.envMap ? '#define ' + envMapBlendingDefine : '', + parameters.lightMap ? '#define USE_LIGHTMAP' : '', + parameters.aoMap ? '#define USE_AOMAP' : '', + parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '', + parameters.bumpMap ? '#define USE_BUMPMAP' : '', + parameters.normalMap ? '#define USE_NORMALMAP' : '', + parameters.specularMap ? '#define USE_SPECULARMAP' : '', + parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '', + parameters.metalnessMap ? '#define USE_METALNESSMAP' : '', + parameters.alphaMap ? '#define USE_ALPHAMAP' : '', + parameters.vertexColors ? '#define USE_COLOR' : '', + + parameters.gradientMap ? '#define USE_GRADIENTMAP' : '', + + parameters.flatShading ? '#define FLAT_SHADED' : '', + + parameters.doubleSided ? '#define DOUBLE_SIDED' : '', + parameters.flipSided ? '#define FLIP_SIDED' : '', + + '#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes, + '#define UNION_CLIPPING_PLANES ' + ( parameters.numClippingPlanes - parameters.numClipIntersection ), + + parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '', + parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '', + + parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '', + + parameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '', + + parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '', + parameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '', + + parameters.envMap && extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '', + + 'uniform mat4 viewMatrix;', + 'uniform vec3 cameraPosition;', + + ( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '', + ( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below + ( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '', + + parameters.dithering ? '#define DITHERING' : '', + + ( 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 + parameters.mapEncoding ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '', + parameters.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '', + parameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '', + parameters.outputEncoding ? getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputEncoding ) : '', + + parameters.depthPacking ? '#define DEPTH_PACKING ' + material.depthPacking : '', + + '\n' + + ].filter( filterEmptyLine ).join( '\n' ); + + } + + vertexShader = parseIncludes( vertexShader ); + vertexShader = replaceLightNums( vertexShader, parameters ); + + fragmentShader = parseIncludes( fragmentShader ); + fragmentShader = replaceLightNums( fragmentShader, parameters ); + + if ( ! material.isShaderMaterial ) { + + vertexShader = unrollLoops( vertexShader ); + fragmentShader = unrollLoops( fragmentShader ); + + } + + var vertexGlsl = prefixVertex + vertexShader; + var fragmentGlsl = prefixFragment + fragmentShader; + + // console.log( '*VERTEX*', vertexGlsl ); + // console.log( '*FRAGMENT*', fragmentGlsl ); + + var glVertexShader = WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl ); + var glFragmentShader = WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl ); + + gl.attachShader( program, glVertexShader ); + gl.attachShader( program, glFragmentShader ); + + // Force a particular attribute to index 0. + + if ( material.index0AttributeName !== undefined ) { + + gl.bindAttribLocation( program, 0, material.index0AttributeName ); + + } else if ( parameters.morphTargets === true ) { + + // programs with morphTargets displace position out of attribute 0 + gl.bindAttribLocation( program, 0, 'position' ); + + } + + gl.linkProgram( program ); + + var programLog = gl.getProgramInfoLog( program ); + var vertexLog = gl.getShaderInfoLog( glVertexShader ); + var fragmentLog = gl.getShaderInfoLog( glFragmentShader ); + + var runnable = true; + var haveDiagnostics = true; + + // console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) ); + // console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) ); + + if ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) { + + runnable = false; + + console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog ); + + } else if ( programLog !== '' ) { + + console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog ); + + } else if ( vertexLog === '' || fragmentLog === '' ) { + + haveDiagnostics = false; + + } + + if ( haveDiagnostics ) { + + this.diagnostics = { + + runnable: runnable, + material: material, + + programLog: programLog, + + vertexShader: { + + log: vertexLog, + prefix: prefixVertex + + }, + + fragmentShader: { + + log: fragmentLog, + prefix: prefixFragment + + } + + }; + + } + + // clean up + + gl.deleteShader( glVertexShader ); + gl.deleteShader( glFragmentShader ); + + // set up caching for uniform locations + + var cachedUniforms; + + this.getUniforms = function () { + + if ( cachedUniforms === undefined ) { + + cachedUniforms = new WebGLUniforms( gl, program, renderer ); + + } + + return cachedUniforms; + + }; + + // set up caching for attribute locations + + var cachedAttributes; + + this.getAttributes = function () { + + if ( cachedAttributes === undefined ) { + + cachedAttributes = fetchAttributeLocations( gl, program ); + + } + + return cachedAttributes; + + }; + + // free resource + + this.destroy = function () { + + gl.deleteProgram( program ); + this.program = undefined; + + }; + + // DEPRECATED + + Object.defineProperties( this, { + + uniforms: { + get: function () { + + console.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' ); + return this.getUniforms(); + + } + }, + + attributes: { + get: function () { + + console.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' ); + return this.getAttributes(); + + } + } + + } ); + + + // + + this.id = programIdCount ++; + this.code = code; + this.usedTimes = 1; + this.program = program; + this.vertexShader = glVertexShader; + this.fragmentShader = glFragmentShader; + + return this; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLPrograms( renderer, extensions, capabilities ) { + + var programs = []; + + var shaderIDs = { + MeshDepthMaterial: 'depth', + MeshDistanceMaterial: 'distanceRGBA', + MeshNormalMaterial: 'normal', + MeshBasicMaterial: 'basic', + MeshLambertMaterial: 'lambert', + MeshPhongMaterial: 'phong', + MeshToonMaterial: 'phong', + MeshStandardMaterial: 'physical', + MeshPhysicalMaterial: 'physical', + LineBasicMaterial: 'basic', + LineDashedMaterial: 'dashed', + PointsMaterial: 'points', + ShadowMaterial: 'shadow' + }; + + var parameterNames = [ + "precision", "supportsVertexTextures", "map", "mapEncoding", "envMap", "envMapMode", "envMapEncoding", + "lightMap", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "displacementMap", "specularMap", + "roughnessMap", "metalnessMap", "gradientMap", + "alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp", + "flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning", + "maxBones", "useVertexTexture", "morphTargets", "morphNormals", + "maxMorphTargets", "maxMorphNormals", "premultipliedAlpha", + "numDirLights", "numPointLights", "numSpotLights", "numHemiLights", "numRectAreaLights", + "shadowMapEnabled", "shadowMapType", "toneMapping", 'physicallyCorrectLights', + "alphaTest", "doubleSided", "flipSided", "numClippingPlanes", "numClipIntersection", "depthPacking", "dithering" + ]; + + + function allocateBones( object ) { + + var skeleton = object.skeleton; + var bones = skeleton.bones; + + if ( capabilities.floatVertexTextures ) { + + return 1024; + + } else { + + // default for when object is not specified + // ( for example when prebuilding shader to be used with multiple objects ) + // + // - leave some extra space for other uniforms + // - limit here is ANGLE's 254 max uniform vectors + // (up to 54 should be safe) + + var nVertexUniforms = capabilities.maxVertexUniforms; + var nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 ); + + var maxBones = Math.min( nVertexMatrices, bones.length ); + + if ( maxBones < bones.length ) { + + console.warn( 'THREE.WebGLRenderer: Skeleton has ' + bones.length + ' bones. This GPU supports ' + maxBones + '.' ); + return 0; + + } + + return maxBones; + + } + + } + + function getTextureEncodingFromMap( map, gammaOverrideLinear ) { + + var encoding; + + if ( ! map ) { + + encoding = LinearEncoding; + + } else if ( map.isTexture ) { + + encoding = map.encoding; + + } else if ( map.isWebGLRenderTarget ) { + + console.warn( "THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead." ); + encoding = map.texture.encoding; + + } + + // add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point. + if ( encoding === LinearEncoding && gammaOverrideLinear ) { + + encoding = GammaEncoding; + + } + + return encoding; + + } + + this.getParameters = function ( material, lights, shadows, fog, nClipPlanes, nClipIntersection, object ) { + + var shaderID = shaderIDs[ material.type ]; + + // heuristics to create shader parameters according to lights in the scene + // (not to blow over maxLights budget) + + var maxBones = object.isSkinnedMesh ? allocateBones( object ) : 0; + var precision = capabilities.precision; + + if ( material.precision !== null ) { + + precision = capabilities.getMaxPrecision( material.precision ); + + if ( precision !== material.precision ) { + + console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' ); + + } + + } + + var currentRenderTarget = renderer.getRenderTarget(); + + var parameters = { + + shaderID: shaderID, + + precision: precision, + supportsVertexTextures: capabilities.vertexTextures, + outputEncoding: getTextureEncodingFromMap( ( ! currentRenderTarget ) ? null : currentRenderTarget.texture, renderer.gammaOutput ), + map: !! material.map, + mapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ), + envMap: !! material.envMap, + envMapMode: material.envMap && material.envMap.mapping, + envMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ), + envMapCubeUV: ( !! material.envMap ) && ( ( material.envMap.mapping === CubeUVReflectionMapping ) || ( material.envMap.mapping === CubeUVRefractionMapping ) ), + lightMap: !! material.lightMap, + aoMap: !! material.aoMap, + emissiveMap: !! material.emissiveMap, + emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ), + bumpMap: !! material.bumpMap, + normalMap: !! material.normalMap, + displacementMap: !! material.displacementMap, + roughnessMap: !! material.roughnessMap, + metalnessMap: !! material.metalnessMap, + specularMap: !! material.specularMap, + alphaMap: !! material.alphaMap, + + gradientMap: !! material.gradientMap, + + combine: material.combine, + + vertexColors: material.vertexColors, + + fog: !! fog, + useFog: material.fog, + fogExp: ( fog && fog.isFogExp2 ), + + flatShading: material.flatShading, + + sizeAttenuation: material.sizeAttenuation, + logarithmicDepthBuffer: capabilities.logarithmicDepthBuffer, + + skinning: material.skinning && maxBones > 0, + maxBones: maxBones, + useVertexTexture: capabilities.floatVertexTextures, + + morphTargets: material.morphTargets, + morphNormals: material.morphNormals, + maxMorphTargets: renderer.maxMorphTargets, + maxMorphNormals: renderer.maxMorphNormals, + + numDirLights: lights.directional.length, + numPointLights: lights.point.length, + numSpotLights: lights.spot.length, + numRectAreaLights: lights.rectArea.length, + numHemiLights: lights.hemi.length, + + numClippingPlanes: nClipPlanes, + numClipIntersection: nClipIntersection, + + dithering: material.dithering, + + shadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && shadows.length > 0, + shadowMapType: renderer.shadowMap.type, + + toneMapping: renderer.toneMapping, + physicallyCorrectLights: renderer.physicallyCorrectLights, + + premultipliedAlpha: material.premultipliedAlpha, + + alphaTest: material.alphaTest, + doubleSided: material.side === DoubleSide, + flipSided: material.side === BackSide, + + depthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false + + }; + + return parameters; + + }; + + this.getProgramCode = function ( material, parameters ) { + + var array = []; + + if ( parameters.shaderID ) { + + array.push( parameters.shaderID ); + + } else { + + array.push( material.fragmentShader ); + array.push( material.vertexShader ); + + } + + if ( material.defines !== undefined ) { + + for ( var name in material.defines ) { + + array.push( name ); + array.push( material.defines[ name ] ); + + } + + } + + for ( var i = 0; i < parameterNames.length; i ++ ) { + + array.push( parameters[ parameterNames[ i ] ] ); + + } + + array.push( material.onBeforeCompile.toString() ); + + array.push( renderer.gammaOutput ); + + return array.join(); + + }; + + this.acquireProgram = function ( material, shader, parameters, code ) { + + var program; + + // Check if code has been already compiled + for ( var p = 0, pl = programs.length; p < pl; p ++ ) { + + var programInfo = programs[ p ]; + + if ( programInfo.code === code ) { + + program = programInfo; + ++ program.usedTimes; + + break; + + } + + } + + if ( program === undefined ) { + + program = new WebGLProgram( renderer, extensions, code, material, shader, parameters ); + programs.push( program ); + + } + + return program; + + }; + + this.releaseProgram = function ( program ) { + + if ( -- program.usedTimes === 0 ) { + + // Remove from unordered set + var i = programs.indexOf( program ); + programs[ i ] = programs[ programs.length - 1 ]; + programs.pop(); + + // Free WebGL resources + program.destroy(); + + } + + }; + + // Exposed for resource monitoring & error feedback via renderer.info: + this.programs = programs; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, infoMemory ) { + + var _isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof window.WebGL2RenderingContext ); + var _videoTextures = {}; + + // + + function clampToMaxSize( image, maxSize ) { + + if ( image.width > maxSize || image.height > maxSize ) { + + // Warning: Scaling through the canvas will only work with images that use + // premultiplied alpha. + + var scale = maxSize / Math.max( image.width, image.height ); + + var canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ); + canvas.width = Math.floor( image.width * scale ); + canvas.height = Math.floor( image.height * scale ); + + var context = canvas.getContext( '2d' ); + context.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height ); + + console.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image ); + + return canvas; + + } + + return image; + + } + + function isPowerOfTwo( image ) { + + return _Math.isPowerOfTwo( image.width ) && _Math.isPowerOfTwo( image.height ); + + } + + function makePowerOfTwo( image ) { + + if ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement || image instanceof ImageBitmap ) { + + var canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ); + canvas.width = _Math.floorPowerOfTwo( image.width ); + canvas.height = _Math.floorPowerOfTwo( image.height ); + + var context = canvas.getContext( '2d' ); + context.drawImage( image, 0, 0, canvas.width, canvas.height ); + + console.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image ); + + return canvas; + + } + + return image; + + } + + function textureNeedsPowerOfTwo( texture ) { + + return ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) || + ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ); + + } + + function textureNeedsGenerateMipmaps( texture, isPowerOfTwo ) { + + return texture.generateMipmaps && isPowerOfTwo && + texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter; + + } + + // Fallback filters for non-power-of-2 textures + + function filterFallback( f ) { + + if ( f === NearestFilter || f === NearestMipMapNearestFilter || f === NearestMipMapLinearFilter ) { + + return _gl.NEAREST; + + } + + return _gl.LINEAR; + + } + + // + + function onTextureDispose( event ) { + + var texture = event.target; + + texture.removeEventListener( 'dispose', onTextureDispose ); + + deallocateTexture( texture ); + + if ( texture.isVideoTexture ) { + + delete _videoTextures[ texture.id ]; + + } + + infoMemory.textures --; + + } + + function onRenderTargetDispose( event ) { + + var renderTarget = event.target; + + renderTarget.removeEventListener( 'dispose', onRenderTargetDispose ); + + deallocateRenderTarget( renderTarget ); + + infoMemory.textures --; + + } + + // + + function deallocateTexture( texture ) { + + var textureProperties = properties.get( texture ); + + if ( texture.image && textureProperties.__image__webglTextureCube ) { + + // cube texture + + _gl.deleteTexture( textureProperties.__image__webglTextureCube ); + + } else { + + // 2D texture + + if ( textureProperties.__webglInit === undefined ) return; + + _gl.deleteTexture( textureProperties.__webglTexture ); + + } + + // remove all webgl properties + properties.remove( texture ); + + } + + function deallocateRenderTarget( renderTarget ) { + + var renderTargetProperties = properties.get( renderTarget ); + var textureProperties = properties.get( renderTarget.texture ); + + if ( ! renderTarget ) return; + + if ( textureProperties.__webglTexture !== undefined ) { + + _gl.deleteTexture( textureProperties.__webglTexture ); + + } + + if ( renderTarget.depthTexture ) { + + renderTarget.depthTexture.dispose(); + + } + + if ( renderTarget.isWebGLRenderTargetCube ) { + + for ( var i = 0; i < 6; i ++ ) { + + _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] ); + if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] ); + + } + + } else { + + _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer ); + if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer ); + + } + + properties.remove( renderTarget.texture ); + properties.remove( renderTarget ); + + } + + // + + + + function setTexture2D( texture, slot ) { + + var textureProperties = properties.get( texture ); + + if ( texture.version > 0 && textureProperties.__version !== texture.version ) { + + var image = texture.image; + + if ( image === undefined ) { + + console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined', texture ); + + } else if ( image.complete === false ) { + + console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture ); + + } else { + + uploadTexture( textureProperties, texture, slot ); + return; + + } + + } + + state.activeTexture( _gl.TEXTURE0 + slot ); + state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); + + } + + function setTextureCube( texture, slot ) { + + var textureProperties = properties.get( texture ); + + if ( texture.image.length === 6 ) { + + if ( texture.version > 0 && textureProperties.__version !== texture.version ) { + + if ( ! textureProperties.__image__webglTextureCube ) { + + texture.addEventListener( 'dispose', onTextureDispose ); + + textureProperties.__image__webglTextureCube = _gl.createTexture(); + + infoMemory.textures ++; + + } + + state.activeTexture( _gl.TEXTURE0 + slot ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube ); + + _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); + + var isCompressed = ( texture && texture.isCompressedTexture ); + var isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture ); + + var cubeImage = []; + + for ( var i = 0; i < 6; i ++ ) { + + if ( ! isCompressed && ! isDataTexture ) { + + cubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize ); + + } else { + + cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ]; + + } + + } + + var image = cubeImage[ 0 ], + isPowerOfTwoImage = isPowerOfTwo( image ), + glFormat = utils.convert( texture.format ), + glType = utils.convert( texture.type ); + + setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage ); + + for ( var i = 0; i < 6; i ++ ) { + + if ( ! isCompressed ) { + + if ( isDataTexture ) { + + state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data ); + + } else { + + state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] ); + + } + + } else { + + var mipmap, mipmaps = cubeImage[ i ].mipmaps; + + for ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) { + + mipmap = mipmaps[ j ]; + + if ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) { + + if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) { + + state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data ); + + } else { + + console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' ); + + } + + } else { + + state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); + + } + + } + + } + + } + + if ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) { + + _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP ); + + } + + textureProperties.__version = texture.version; + + if ( texture.onUpdate ) texture.onUpdate( texture ); + + } else { + + state.activeTexture( _gl.TEXTURE0 + slot ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube ); + + } + + } + + } + + function setTextureCubeDynamic( texture, slot ) { + + state.activeTexture( _gl.TEXTURE0 + slot ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture ); + + } + + function setTextureParameters( textureType, texture, isPowerOfTwoImage ) { + + var extension; + + if ( isPowerOfTwoImage ) { + + _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, utils.convert( texture.wrapS ) ); + _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, utils.convert( texture.wrapT ) ); + + _gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, utils.convert( texture.magFilter ) ); + _gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, utils.convert( texture.minFilter ) ); + + } else { + + _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE ); + _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE ); + + if ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) { + + console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture ); + + } + + _gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) ); + _gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) ); + + if ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) { + + console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture ); + + } + + } + + extension = extensions.get( 'EXT_texture_filter_anisotropic' ); + + if ( extension ) { + + if ( texture.type === FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return; + if ( texture.type === HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return; + + if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) { + + _gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) ); + properties.get( texture ).__currentAnisotropy = texture.anisotropy; + + } + + } + + } + + function uploadTexture( textureProperties, texture, slot ) { + + if ( textureProperties.__webglInit === undefined ) { + + textureProperties.__webglInit = true; + + texture.addEventListener( 'dispose', onTextureDispose ); + + textureProperties.__webglTexture = _gl.createTexture(); + + if ( texture.isVideoTexture ) { + + _videoTextures[ texture.id ] = texture; + + } + + infoMemory.textures ++; + + } + + state.activeTexture( _gl.TEXTURE0 + slot ); + state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); + + _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); + _gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha ); + _gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment ); + + var image = clampToMaxSize( texture.image, capabilities.maxTextureSize ); + + if ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) { + + image = makePowerOfTwo( image ); + + } + + var isPowerOfTwoImage = isPowerOfTwo( image ), + glFormat = utils.convert( texture.format ), + glType = utils.convert( texture.type ); + + setTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage ); + + var mipmap, mipmaps = texture.mipmaps; + + if ( texture.isDepthTexture ) { + + // populate depth texture with dummy data + + var internalFormat = _gl.DEPTH_COMPONENT; + + if ( texture.type === FloatType ) { + + if ( ! _isWebGL2 ) throw new Error( 'Float Depth Texture only supported in WebGL2.0' ); + internalFormat = _gl.DEPTH_COMPONENT32F; + + } else if ( _isWebGL2 ) { + + // WebGL 2.0 requires signed internalformat for glTexImage2D + internalFormat = _gl.DEPTH_COMPONENT16; + + } + + if ( texture.format === DepthFormat && internalFormat === _gl.DEPTH_COMPONENT ) { + + // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are + // DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT + // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/) + if ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) { + + console.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' ); + + texture.type = UnsignedShortType; + glType = utils.convert( texture.type ); + + } + + } + + // Depth stencil textures need the DEPTH_STENCIL internal format + // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/) + if ( texture.format === DepthStencilFormat ) { + + internalFormat = _gl.DEPTH_STENCIL; + + // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are + // DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL. + // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/) + if ( texture.type !== UnsignedInt248Type ) { + + console.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' ); + + texture.type = UnsignedInt248Type; + glType = utils.convert( texture.type ); + + } + + } + + state.texImage2D( _gl.TEXTURE_2D, 0, internalFormat, image.width, image.height, 0, glFormat, glType, null ); + + } else if ( texture.isDataTexture ) { + + // use manually created mipmaps if available + // if there are no manual mipmaps + // set 0 level mipmap and then use GL to generate other mipmap levels + + if ( mipmaps.length > 0 && isPowerOfTwoImage ) { + + for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { + + mipmap = mipmaps[ i ]; + state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); + + } + + texture.generateMipmaps = false; + + } else { + + state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data ); + + } + + } else if ( texture.isCompressedTexture ) { + + for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { + + mipmap = mipmaps[ i ]; + + if ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) { + + if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) { + + state.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data ); + + } else { + + console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' ); + + } + + } else { + + state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); + + } + + } + + } else { + + // regular Texture (image, video, canvas) + + // use manually created mipmaps if available + // if there are no manual mipmaps + // set 0 level mipmap and then use GL to generate other mipmap levels + + if ( mipmaps.length > 0 && isPowerOfTwoImage ) { + + for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { + + mipmap = mipmaps[ i ]; + state.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap ); + + } + + texture.generateMipmaps = false; + + } else { + + state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image ); + + } + + } + + if ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) _gl.generateMipmap( _gl.TEXTURE_2D ); + + textureProperties.__version = texture.version; + + if ( texture.onUpdate ) texture.onUpdate( texture ); + + } + + // Render targets + + // Setup storage for target texture and bind it to correct framebuffer + function setupFrameBufferTexture( framebuffer, renderTarget, attachment, textureTarget ) { + + var glFormat = utils.convert( renderTarget.texture.format ); + var glType = utils.convert( renderTarget.texture.type ); + state.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null ); + _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); + _gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 ); + _gl.bindFramebuffer( _gl.FRAMEBUFFER, null ); + + } + + // Setup storage for internal depth/stencil buffers and bind to correct framebuffer + function setupRenderBufferStorage( renderbuffer, renderTarget ) { + + _gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer ); + + if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) { + + _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height ); + _gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer ); + + } else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) { + + _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height ); + _gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer ); + + } else { + + // FIXME: We don't support !depth !stencil + _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height ); + + } + + _gl.bindRenderbuffer( _gl.RENDERBUFFER, null ); + + } + + // Setup resources for a Depth Texture for a FBO (needs an extension) + function setupDepthTexture( framebuffer, renderTarget ) { + + var isCube = ( renderTarget && renderTarget.isWebGLRenderTargetCube ); + if ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' ); + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); + + if ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) { + + throw new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' ); + + } + + // upload an empty depth texture with framebuffer size + if ( ! properties.get( renderTarget.depthTexture ).__webglTexture || + renderTarget.depthTexture.image.width !== renderTarget.width || + renderTarget.depthTexture.image.height !== renderTarget.height ) { + + renderTarget.depthTexture.image.width = renderTarget.width; + renderTarget.depthTexture.image.height = renderTarget.height; + renderTarget.depthTexture.needsUpdate = true; + + } + + setTexture2D( renderTarget.depthTexture, 0 ); + + var webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture; + + if ( renderTarget.depthTexture.format === DepthFormat ) { + + _gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 ); + + } else if ( renderTarget.depthTexture.format === DepthStencilFormat ) { + + _gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 ); + + } else { + + throw new Error( 'Unknown depthTexture format' ); + + } + + } + + // Setup GL resources for a non-texture depth buffer + function setupDepthRenderbuffer( renderTarget ) { + + var renderTargetProperties = properties.get( renderTarget ); + + var isCube = ( renderTarget.isWebGLRenderTargetCube === true ); + + if ( renderTarget.depthTexture ) { + + if ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' ); + + setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget ); + + } else { + + if ( isCube ) { + + renderTargetProperties.__webglDepthbuffer = []; + + for ( var i = 0; i < 6; i ++ ) { + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] ); + renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer(); + setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget ); + + } + + } else { + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer ); + renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer(); + setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget ); + + } + + } + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, null ); + + } + + // Set up GL resources for the render target + function setupRenderTarget( renderTarget ) { + + var renderTargetProperties = properties.get( renderTarget ); + var textureProperties = properties.get( renderTarget.texture ); + + renderTarget.addEventListener( 'dispose', onRenderTargetDispose ); + + textureProperties.__webglTexture = _gl.createTexture(); + + infoMemory.textures ++; + + var isCube = ( renderTarget.isWebGLRenderTargetCube === true ); + var isTargetPowerOfTwo = isPowerOfTwo( renderTarget ); + + // Setup framebuffer + + if ( isCube ) { + + renderTargetProperties.__webglFramebuffer = []; + + for ( var i = 0; i < 6; i ++ ) { + + renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer(); + + } + + } else { + + renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer(); + + } + + // Setup color buffer + + if ( isCube ) { + + state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture ); + setTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo ); + + for ( var i = 0; i < 6; i ++ ) { + + setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i ); + + } + + if ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, null ); + + } else { + + state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); + setTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo ); + setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D ); + + if ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_2D ); + state.bindTexture( _gl.TEXTURE_2D, null ); + + } + + // Setup depth and stencil buffers + + if ( renderTarget.depthBuffer ) { + + setupDepthRenderbuffer( renderTarget ); + + } + + } + + function updateRenderTargetMipmap( renderTarget ) { + + var texture = renderTarget.texture; + var isTargetPowerOfTwo = isPowerOfTwo( renderTarget ); + + if ( textureNeedsGenerateMipmaps( texture, isTargetPowerOfTwo ) ) { + + var target = renderTarget.isWebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D; + var webglTexture = properties.get( texture ).__webglTexture; + + state.bindTexture( target, webglTexture ); + _gl.generateMipmap( target ); + state.bindTexture( target, null ); + + } + + } + + function updateVideoTextures() { + + for ( var id in _videoTextures ) { + + _videoTextures[ id ].update(); + + } + + } + + this.setTexture2D = setTexture2D; + this.setTextureCube = setTextureCube; + this.setTextureCubeDynamic = setTextureCubeDynamic; + this.setupRenderTarget = setupRenderTarget; + this.updateRenderTargetMipmap = updateRenderTargetMipmap; + this.updateVideoTextures = updateVideoTextures; + + } + + /** + * @author fordacious / fordacious.github.io + */ + + function WebGLProperties() { + + var properties = {}; + + function get( object ) { + + var uuid = object.uuid; + var map = properties[ uuid ]; + + if ( map === undefined ) { + + map = {}; + properties[ uuid ] = map; + + } + + return map; + + } + + function remove( object ) { + + delete properties[ object.uuid ]; + + } + + function clear() { + + properties = {}; + + } + + return { + get: get, + remove: remove, + clear: clear + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLState( gl, extensions, utils ) { + + function ColorBuffer() { + + var locked = false; + + var color = new Vector4(); + var currentColorMask = null; + var currentColorClear = new Vector4( 0, 0, 0, 0 ); + + return { + + setMask: function ( colorMask ) { + + if ( currentColorMask !== colorMask && ! locked ) { + + gl.colorMask( colorMask, colorMask, colorMask, colorMask ); + currentColorMask = colorMask; + + } + + }, + + setLocked: function ( lock ) { + + locked = lock; + + }, + + setClear: function ( r, g, b, a, premultipliedAlpha ) { + + if ( premultipliedAlpha === true ) { + + r *= a; g *= a; b *= a; + + } + + color.set( r, g, b, a ); + + if ( currentColorClear.equals( color ) === false ) { + + gl.clearColor( r, g, b, a ); + currentColorClear.copy( color ); + + } + + }, + + reset: function () { + + locked = false; + + currentColorMask = null; + currentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state + + } + + }; + + } + + function DepthBuffer() { + + var locked = false; + + var currentDepthMask = null; + var currentDepthFunc = null; + var currentDepthClear = null; + + return { + + setTest: function ( depthTest ) { + + if ( depthTest ) { + + enable( gl.DEPTH_TEST ); + + } else { + + disable( gl.DEPTH_TEST ); + + } + + }, + + setMask: function ( depthMask ) { + + if ( currentDepthMask !== depthMask && ! locked ) { + + gl.depthMask( depthMask ); + currentDepthMask = depthMask; + + } + + }, + + setFunc: function ( depthFunc ) { + + if ( currentDepthFunc !== depthFunc ) { + + if ( depthFunc ) { + + switch ( depthFunc ) { + + case NeverDepth: + + gl.depthFunc( gl.NEVER ); + break; + + case AlwaysDepth: + + gl.depthFunc( gl.ALWAYS ); + break; + + case LessDepth: + + gl.depthFunc( gl.LESS ); + break; + + case LessEqualDepth: + + gl.depthFunc( gl.LEQUAL ); + break; + + case EqualDepth: + + gl.depthFunc( gl.EQUAL ); + break; + + case GreaterEqualDepth: + + gl.depthFunc( gl.GEQUAL ); + break; + + case GreaterDepth: + + gl.depthFunc( gl.GREATER ); + break; + + case NotEqualDepth: + + gl.depthFunc( gl.NOTEQUAL ); + break; + + default: + + gl.depthFunc( gl.LEQUAL ); + + } + + } else { + + gl.depthFunc( gl.LEQUAL ); + + } + + currentDepthFunc = depthFunc; + + } + + }, + + setLocked: function ( lock ) { + + locked = lock; + + }, + + setClear: function ( depth ) { + + if ( currentDepthClear !== depth ) { + + gl.clearDepth( depth ); + currentDepthClear = depth; + + } + + }, + + reset: function () { + + locked = false; + + currentDepthMask = null; + currentDepthFunc = null; + currentDepthClear = null; + + } + + }; + + } + + function StencilBuffer() { + + var locked = false; + + var currentStencilMask = null; + var currentStencilFunc = null; + var currentStencilRef = null; + var currentStencilFuncMask = null; + var currentStencilFail = null; + var currentStencilZFail = null; + var currentStencilZPass = null; + var currentStencilClear = null; + + return { + + setTest: function ( stencilTest ) { + + if ( stencilTest ) { + + enable( gl.STENCIL_TEST ); + + } else { + + disable( gl.STENCIL_TEST ); + + } + + }, + + setMask: function ( stencilMask ) { + + if ( currentStencilMask !== stencilMask && ! locked ) { + + gl.stencilMask( stencilMask ); + currentStencilMask = stencilMask; + + } + + }, + + setFunc: function ( stencilFunc, stencilRef, stencilMask ) { + + if ( currentStencilFunc !== stencilFunc || + currentStencilRef !== stencilRef || + currentStencilFuncMask !== stencilMask ) { + + gl.stencilFunc( stencilFunc, stencilRef, stencilMask ); + + currentStencilFunc = stencilFunc; + currentStencilRef = stencilRef; + currentStencilFuncMask = stencilMask; + + } + + }, + + setOp: function ( stencilFail, stencilZFail, stencilZPass ) { + + if ( currentStencilFail !== stencilFail || + currentStencilZFail !== stencilZFail || + currentStencilZPass !== stencilZPass ) { + + gl.stencilOp( stencilFail, stencilZFail, stencilZPass ); + + currentStencilFail = stencilFail; + currentStencilZFail = stencilZFail; + currentStencilZPass = stencilZPass; + + } + + }, + + setLocked: function ( lock ) { + + locked = lock; + + }, + + setClear: function ( stencil ) { + + if ( currentStencilClear !== stencil ) { + + gl.clearStencil( stencil ); + currentStencilClear = stencil; + + } + + }, + + reset: function () { + + locked = false; + + currentStencilMask = null; + currentStencilFunc = null; + currentStencilRef = null; + currentStencilFuncMask = null; + currentStencilFail = null; + currentStencilZFail = null; + currentStencilZPass = null; + currentStencilClear = null; + + } + + }; + + } + + // + + var colorBuffer = new ColorBuffer(); + var depthBuffer = new DepthBuffer(); + var stencilBuffer = new StencilBuffer(); + + var maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS ); + var newAttributes = new Uint8Array( maxVertexAttributes ); + var enabledAttributes = new Uint8Array( maxVertexAttributes ); + var attributeDivisors = new Uint8Array( maxVertexAttributes ); + + var capabilities = {}; + + var compressedTextureFormats = null; + + var currentProgram = null; + + var currentBlending = null; + var currentBlendEquation = null; + var currentBlendSrc = null; + var currentBlendDst = null; + var currentBlendEquationAlpha = null; + var currentBlendSrcAlpha = null; + var currentBlendDstAlpha = null; + var currentPremultipledAlpha = false; + + var currentFlipSided = null; + var currentCullFace = null; + + var currentLineWidth = null; + + var currentPolygonOffsetFactor = null; + var currentPolygonOffsetUnits = null; + + var maxTextures = gl.getParameter( gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS ); + + var version = parseFloat( /^WebGL\ ([0-9])/.exec( gl.getParameter( gl.VERSION ) )[ 1 ] ); + var lineWidthAvailable = parseFloat( version ) >= 1.0; + + var currentTextureSlot = null; + var currentBoundTextures = {}; + + var currentScissor = new Vector4(); + var currentViewport = new Vector4(); + + function createTexture( type, target, count ) { + + var data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4. + var texture = gl.createTexture(); + + gl.bindTexture( type, texture ); + gl.texParameteri( type, gl.TEXTURE_MIN_FILTER, gl.NEAREST ); + gl.texParameteri( type, gl.TEXTURE_MAG_FILTER, gl.NEAREST ); + + for ( var i = 0; i < count; i ++ ) { + + gl.texImage2D( target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data ); + + } + + return texture; + + } + + var emptyTextures = {}; + emptyTextures[ gl.TEXTURE_2D ] = createTexture( gl.TEXTURE_2D, gl.TEXTURE_2D, 1 ); + emptyTextures[ gl.TEXTURE_CUBE_MAP ] = createTexture( gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6 ); + + // init + + colorBuffer.setClear( 0, 0, 0, 1 ); + depthBuffer.setClear( 1 ); + stencilBuffer.setClear( 0 ); + + enable( gl.DEPTH_TEST ); + depthBuffer.setFunc( LessEqualDepth ); + + setFlipSided( false ); + setCullFace( CullFaceBack ); + enable( gl.CULL_FACE ); + + enable( gl.BLEND ); + setBlending( NormalBlending ); + + // + + function initAttributes() { + + for ( var i = 0, l = newAttributes.length; i < l; i ++ ) { + + newAttributes[ i ] = 0; + + } + + } + + function enableAttribute( attribute ) { + + newAttributes[ attribute ] = 1; + + if ( enabledAttributes[ attribute ] === 0 ) { + + gl.enableVertexAttribArray( attribute ); + enabledAttributes[ attribute ] = 1; + + } + + if ( attributeDivisors[ attribute ] !== 0 ) { + + var extension = extensions.get( 'ANGLE_instanced_arrays' ); + + extension.vertexAttribDivisorANGLE( attribute, 0 ); + attributeDivisors[ attribute ] = 0; + + } + + } + + function enableAttributeAndDivisor( attribute, meshPerAttribute ) { + + newAttributes[ attribute ] = 1; + + if ( enabledAttributes[ attribute ] === 0 ) { + + gl.enableVertexAttribArray( attribute ); + enabledAttributes[ attribute ] = 1; + + } + + if ( attributeDivisors[ attribute ] !== meshPerAttribute ) { + + var extension = extensions.get( 'ANGLE_instanced_arrays' ); + + extension.vertexAttribDivisorANGLE( attribute, meshPerAttribute ); + attributeDivisors[ attribute ] = meshPerAttribute; + + } + + } + + function disableUnusedAttributes() { + + for ( var i = 0, l = enabledAttributes.length; i !== l; ++ i ) { + + if ( enabledAttributes[ i ] !== newAttributes[ i ] ) { + + gl.disableVertexAttribArray( i ); + enabledAttributes[ i ] = 0; + + } + + } + + } + + function enable( id ) { + + if ( capabilities[ id ] !== true ) { + + gl.enable( id ); + capabilities[ id ] = true; + + } + + } + + function disable( id ) { + + if ( capabilities[ id ] !== false ) { + + gl.disable( id ); + capabilities[ id ] = false; + + } + + } + + function getCompressedTextureFormats() { + + if ( compressedTextureFormats === null ) { + + compressedTextureFormats = []; + + if ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) || + extensions.get( 'WEBGL_compressed_texture_s3tc' ) || + extensions.get( 'WEBGL_compressed_texture_etc1' ) ) { + + var formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS ); + + for ( var i = 0; i < formats.length; i ++ ) { + + compressedTextureFormats.push( formats[ i ] ); + + } + + } + + } + + return compressedTextureFormats; + + } + + function useProgram( program ) { + + if ( currentProgram !== program ) { + + gl.useProgram( program ); + + currentProgram = program; + + return true; + + } + + return false; + + } + + function setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) { + + if ( blending !== NoBlending ) { + + enable( gl.BLEND ); + + } else { + + disable( gl.BLEND ); + + } + + if ( blending !== CustomBlending ) { + + if ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) { + + switch ( blending ) { + + case AdditiveBlending: + + if ( premultipliedAlpha ) { + + gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); + gl.blendFuncSeparate( gl.ONE, gl.ONE, gl.ONE, gl.ONE ); + + } else { + + gl.blendEquation( gl.FUNC_ADD ); + gl.blendFunc( gl.SRC_ALPHA, gl.ONE ); + + } + break; + + case SubtractiveBlending: + + if ( premultipliedAlpha ) { + + gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); + gl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ONE_MINUS_SRC_ALPHA ); + + } else { + + gl.blendEquation( gl.FUNC_ADD ); + gl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR ); + + } + break; + + case MultiplyBlending: + + if ( premultipliedAlpha ) { + + gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); + gl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA ); + + } else { + + gl.blendEquation( gl.FUNC_ADD ); + gl.blendFunc( gl.ZERO, gl.SRC_COLOR ); + + } + break; + + default: + + if ( premultipliedAlpha ) { + + gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); + gl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA ); + + } else { + + gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); + gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA ); + + } + + } + + } + + currentBlendEquation = null; + currentBlendSrc = null; + currentBlendDst = null; + currentBlendEquationAlpha = null; + currentBlendSrcAlpha = null; + currentBlendDstAlpha = null; + + } else { + + blendEquationAlpha = blendEquationAlpha || blendEquation; + blendSrcAlpha = blendSrcAlpha || blendSrc; + blendDstAlpha = blendDstAlpha || blendDst; + + if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) { + + gl.blendEquationSeparate( utils.convert( blendEquation ), utils.convert( blendEquationAlpha ) ); + + currentBlendEquation = blendEquation; + currentBlendEquationAlpha = blendEquationAlpha; + + } + + if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) { + + gl.blendFuncSeparate( utils.convert( blendSrc ), utils.convert( blendDst ), utils.convert( blendSrcAlpha ), utils.convert( blendDstAlpha ) ); + + currentBlendSrc = blendSrc; + currentBlendDst = blendDst; + currentBlendSrcAlpha = blendSrcAlpha; + currentBlendDstAlpha = blendDstAlpha; + + } + + } + + currentBlending = blending; + currentPremultipledAlpha = premultipliedAlpha; + + } + + function setMaterial( material, frontFaceCW ) { + + material.side === DoubleSide + ? disable( gl.CULL_FACE ) + : enable( gl.CULL_FACE ); + + var flipSided = ( material.side === BackSide ); + if ( frontFaceCW ) flipSided = ! flipSided; + + setFlipSided( flipSided ); + + material.transparent === true + ? setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha ) + : setBlending( NoBlending ); + + depthBuffer.setFunc( material.depthFunc ); + depthBuffer.setTest( material.depthTest ); + depthBuffer.setMask( material.depthWrite ); + colorBuffer.setMask( material.colorWrite ); + + setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits ); + + } + + // + + function setFlipSided( flipSided ) { + + if ( currentFlipSided !== flipSided ) { + + if ( flipSided ) { + + gl.frontFace( gl.CW ); + + } else { + + gl.frontFace( gl.CCW ); + + } + + currentFlipSided = flipSided; + + } + + } + + function setCullFace( cullFace ) { + + if ( cullFace !== CullFaceNone ) { + + enable( gl.CULL_FACE ); + + if ( cullFace !== currentCullFace ) { + + if ( cullFace === CullFaceBack ) { + + gl.cullFace( gl.BACK ); + + } else if ( cullFace === CullFaceFront ) { + + gl.cullFace( gl.FRONT ); + + } else { + + gl.cullFace( gl.FRONT_AND_BACK ); + + } + + } + + } else { + + disable( gl.CULL_FACE ); + + } + + currentCullFace = cullFace; + + } + + function setLineWidth( width ) { + + if ( width !== currentLineWidth ) { + + if ( lineWidthAvailable ) gl.lineWidth( width ); + + currentLineWidth = width; + + } + + } + + function setPolygonOffset( polygonOffset, factor, units ) { + + if ( polygonOffset ) { + + enable( gl.POLYGON_OFFSET_FILL ); + + if ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) { + + gl.polygonOffset( factor, units ); + + currentPolygonOffsetFactor = factor; + currentPolygonOffsetUnits = units; + + } + + } else { + + disable( gl.POLYGON_OFFSET_FILL ); + + } + + } + + function setScissorTest( scissorTest ) { + + if ( scissorTest ) { + + enable( gl.SCISSOR_TEST ); + + } else { + + disable( gl.SCISSOR_TEST ); + + } + + } + + // texture + + function activeTexture( webglSlot ) { + + if ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1; + + if ( currentTextureSlot !== webglSlot ) { + + gl.activeTexture( webglSlot ); + currentTextureSlot = webglSlot; + + } + + } + + function bindTexture( webglType, webglTexture ) { + + if ( currentTextureSlot === null ) { + + activeTexture(); + + } + + var boundTexture = currentBoundTextures[ currentTextureSlot ]; + + if ( boundTexture === undefined ) { + + boundTexture = { type: undefined, texture: undefined }; + currentBoundTextures[ currentTextureSlot ] = boundTexture; + + } + + if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) { + + gl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] ); + + boundTexture.type = webglType; + boundTexture.texture = webglTexture; + + } + + } + + function compressedTexImage2D() { + + try { + + gl.compressedTexImage2D.apply( gl, arguments ); + + } catch ( error ) { + + console.error( 'THREE.WebGLState:', error ); + + } + + } + + function texImage2D() { + + try { + + gl.texImage2D.apply( gl, arguments ); + + } catch ( error ) { + + console.error( 'THREE.WebGLState:', error ); + + } + + } + + // + + function scissor( scissor ) { + + if ( currentScissor.equals( scissor ) === false ) { + + gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w ); + currentScissor.copy( scissor ); + + } + + } + + function viewport( viewport ) { + + if ( currentViewport.equals( viewport ) === false ) { + + gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w ); + currentViewport.copy( viewport ); + + } + + } + + // + + function reset() { + + for ( var i = 0; i < enabledAttributes.length; i ++ ) { + + if ( enabledAttributes[ i ] === 1 ) { + + gl.disableVertexAttribArray( i ); + enabledAttributes[ i ] = 0; + + } + + } + + capabilities = {}; + + compressedTextureFormats = null; + + currentTextureSlot = null; + currentBoundTextures = {}; + + currentProgram = null; + + currentBlending = null; + + currentFlipSided = null; + currentCullFace = null; + + colorBuffer.reset(); + depthBuffer.reset(); + stencilBuffer.reset(); + + } + + return { + + buffers: { + color: colorBuffer, + depth: depthBuffer, + stencil: stencilBuffer + }, + + initAttributes: initAttributes, + enableAttribute: enableAttribute, + enableAttributeAndDivisor: enableAttributeAndDivisor, + disableUnusedAttributes: disableUnusedAttributes, + enable: enable, + disable: disable, + getCompressedTextureFormats: getCompressedTextureFormats, + + useProgram: useProgram, + + setBlending: setBlending, + setMaterial: setMaterial, + + setFlipSided: setFlipSided, + setCullFace: setCullFace, + + setLineWidth: setLineWidth, + setPolygonOffset: setPolygonOffset, + + setScissorTest: setScissorTest, + + activeTexture: activeTexture, + bindTexture: bindTexture, + compressedTexImage2D: compressedTexImage2D, + texImage2D: texImage2D, + + scissor: scissor, + viewport: viewport, + + reset: reset + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLCapabilities( gl, extensions, parameters ) { + + var maxAnisotropy; + + function getMaxAnisotropy() { + + if ( maxAnisotropy !== undefined ) return maxAnisotropy; + + var extension = extensions.get( 'EXT_texture_filter_anisotropic' ); + + if ( extension !== null ) { + + maxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT ); + + } else { + + maxAnisotropy = 0; + + } + + return maxAnisotropy; + + } + + function getMaxPrecision( precision ) { + + if ( precision === 'highp' ) { + + if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 && + gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) { + + return 'highp'; + + } + + precision = 'mediump'; + + } + + if ( precision === 'mediump' ) { + + if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 && + gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) { + + return 'mediump'; + + } + + } + + return 'lowp'; + + } + + var precision = parameters.precision !== undefined ? parameters.precision : 'highp'; + var maxPrecision = getMaxPrecision( precision ); + + if ( maxPrecision !== precision ) { + + console.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' ); + precision = maxPrecision; + + } + + var logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true; + + var maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS ); + var maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ); + var maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE ); + var maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE ); + + var maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS ); + var maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS ); + var maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS ); + var maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS ); + + var vertexTextures = maxVertexTextures > 0; + var floatFragmentTextures = !! extensions.get( 'OES_texture_float' ); + var floatVertexTextures = vertexTextures && floatFragmentTextures; + + return { + + getMaxAnisotropy: getMaxAnisotropy, + getMaxPrecision: getMaxPrecision, + + precision: precision, + logarithmicDepthBuffer: logarithmicDepthBuffer, + + maxTextures: maxTextures, + maxVertexTextures: maxVertexTextures, + maxTextureSize: maxTextureSize, + maxCubemapSize: maxCubemapSize, + + maxAttributes: maxAttributes, + maxVertexUniforms: maxVertexUniforms, + maxVaryings: maxVaryings, + maxFragmentUniforms: maxFragmentUniforms, + + vertexTextures: vertexTextures, + floatFragmentTextures: floatFragmentTextures, + floatVertexTextures: floatVertexTextures + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + * @author greggman / http://games.greggman.com/ + * @author zz85 / http://www.lab4games.net/zz85/blog + * @author tschw + */ + + function PerspectiveCamera( fov, aspect, near, far ) { + + Camera.call( this ); + + this.type = 'PerspectiveCamera'; + + this.fov = fov !== undefined ? fov : 50; + this.zoom = 1; + + this.near = near !== undefined ? near : 0.1; + this.far = far !== undefined ? far : 2000; + this.focus = 10; + + this.aspect = aspect !== undefined ? aspect : 1; + this.view = null; + + this.filmGauge = 35; // width of the film (default in millimeters) + this.filmOffset = 0; // horizontal film offset (same unit as gauge) + + this.updateProjectionMatrix(); + + } + + PerspectiveCamera.prototype = Object.assign( Object.create( Camera.prototype ), { + + constructor: PerspectiveCamera, + + isPerspectiveCamera: true, + + copy: function ( source, recursive ) { + + Camera.prototype.copy.call( this, source, recursive ); + + this.fov = source.fov; + this.zoom = source.zoom; + + this.near = source.near; + this.far = source.far; + this.focus = source.focus; + + this.aspect = source.aspect; + this.view = source.view === null ? null : Object.assign( {}, source.view ); + + this.filmGauge = source.filmGauge; + this.filmOffset = source.filmOffset; + + return this; + + }, + + /** + * Sets the FOV by focal length in respect to the current .filmGauge. + * + * The default film gauge is 35, so that the focal length can be specified for + * a 35mm (full frame) camera. + * + * Values for focal length and film gauge must have the same unit. + */ + setFocalLength: function ( focalLength ) { + + // see http://www.bobatkins.com/photography/technical/field_of_view.html + var vExtentSlope = 0.5 * this.getFilmHeight() / focalLength; + + this.fov = _Math.RAD2DEG * 2 * Math.atan( vExtentSlope ); + this.updateProjectionMatrix(); + + }, + + /** + * Calculates the focal length from the current .fov and .filmGauge. + */ + getFocalLength: function () { + + var vExtentSlope = Math.tan( _Math.DEG2RAD * 0.5 * this.fov ); + + return 0.5 * this.getFilmHeight() / vExtentSlope; + + }, + + getEffectiveFOV: function () { + + return _Math.RAD2DEG * 2 * Math.atan( + Math.tan( _Math.DEG2RAD * 0.5 * this.fov ) / this.zoom ); + + }, + + getFilmWidth: function () { + + // film not completely covered in portrait format (aspect < 1) + return this.filmGauge * Math.min( this.aspect, 1 ); + + }, + + getFilmHeight: function () { + + // film not completely covered in landscape format (aspect > 1) + return this.filmGauge / Math.max( this.aspect, 1 ); + + }, + + /** + * Sets an offset in a larger frustum. This is useful for multi-window or + * multi-monitor/multi-machine setups. + * + * For example, if you have 3x2 monitors and each monitor is 1920x1080 and + * the monitors are in grid like this + * + * +---+---+---+ + * | A | B | C | + * +---+---+---+ + * | D | E | F | + * +---+---+---+ + * + * then for each monitor you would call it like this + * + * var w = 1920; + * var h = 1080; + * var fullWidth = w * 3; + * var fullHeight = h * 2; + * + * --A-- + * camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h ); + * --B-- + * camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h ); + * --C-- + * camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h ); + * --D-- + * camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h ); + * --E-- + * camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h ); + * --F-- + * camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h ); + * + * Note there is no reason monitors have to be the same size or in a grid. + */ + setViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) { + + this.aspect = fullWidth / fullHeight; + + if ( this.view === null ) { + + this.view = { + enabled: true, + fullWidth: 1, + fullHeight: 1, + offsetX: 0, + offsetY: 0, + width: 1, + height: 1 + }; + + } + + this.view.enabled = true; + this.view.fullWidth = fullWidth; + this.view.fullHeight = fullHeight; + this.view.offsetX = x; + this.view.offsetY = y; + this.view.width = width; + this.view.height = height; + + this.updateProjectionMatrix(); + + }, + + clearViewOffset: function () { + + if ( this.view !== null ) { + + this.view.enabled = false; + + } + + this.updateProjectionMatrix(); + + }, + + updateProjectionMatrix: function () { + + var near = this.near, + top = near * Math.tan( + _Math.DEG2RAD * 0.5 * this.fov ) / this.zoom, + height = 2 * top, + width = this.aspect * height, + left = - 0.5 * width, + view = this.view; + + if ( this.view !== null && this.view.enabled ) { + + var fullWidth = view.fullWidth, + fullHeight = view.fullHeight; + + left += view.offsetX * width / fullWidth; + top -= view.offsetY * height / fullHeight; + width *= view.width / fullWidth; + height *= view.height / fullHeight; + + } + + var skew = this.filmOffset; + if ( skew !== 0 ) left += near * skew / this.getFilmWidth(); + + this.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far ); + + }, + + toJSON: function ( meta ) { + + var data = Object3D.prototype.toJSON.call( this, meta ); + + data.object.fov = this.fov; + data.object.zoom = this.zoom; + + data.object.near = this.near; + data.object.far = this.far; + data.object.focus = this.focus; + + data.object.aspect = this.aspect; + + if ( this.view !== null ) data.object.view = Object.assign( {}, this.view ); + + data.object.filmGauge = this.filmGauge; + data.object.filmOffset = this.filmOffset; + + return data; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function ArrayCamera( array ) { + + PerspectiveCamera.call( this ); + + this.cameras = array || []; + + } + + ArrayCamera.prototype = Object.assign( Object.create( PerspectiveCamera.prototype ), { + + constructor: ArrayCamera, + + isArrayCamera: true + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebVRManager( renderer ) { + + var scope = this; + + var device = null; + var frameData = null; + + var poseTarget = null; + + if ( typeof window !== 'undefined' && 'VRFrameData' in window ) { + + frameData = new window.VRFrameData(); + + } + + var matrixWorldInverse = new Matrix4(); + + var cameraL = new PerspectiveCamera(); + cameraL.bounds = new Vector4( 0.0, 0.0, 0.5, 1.0 ); + cameraL.layers.enable( 1 ); + + var cameraR = new PerspectiveCamera(); + cameraR.bounds = new Vector4( 0.5, 0.0, 0.5, 1.0 ); + cameraR.layers.enable( 2 ); + + var cameraVR = new ArrayCamera( [ cameraL, cameraR ] ); + cameraVR.layers.enable( 1 ); + cameraVR.layers.enable( 2 ); + + // + + var currentSize, currentPixelRatio; + + function onVRDisplayPresentChange() { + + if ( device !== null && device.isPresenting ) { + + var eyeParameters = device.getEyeParameters( 'left' ); + var renderWidth = eyeParameters.renderWidth; + var renderHeight = eyeParameters.renderHeight; + + currentPixelRatio = renderer.getPixelRatio(); + currentSize = renderer.getSize(); + + renderer.setDrawingBufferSize( renderWidth * 2, renderHeight, 1 ); + + } else if ( scope.enabled ) { + + renderer.setDrawingBufferSize( currentSize.width, currentSize.height, currentPixelRatio ); + + } + + } + + if ( typeof window !== 'undefined' ) { + + window.addEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange, false ); + + } + + // + + this.enabled = false; + + this.getDevice = function () { + + return device; + + }; + + this.setDevice = function ( value ) { + + if ( value !== undefined ) device = value; + + }; + + this.setPoseTarget = function ( object ) { + + if ( object !== undefined ) poseTarget = object; + + }; + + this.getCamera = function ( camera ) { + + if ( device === null ) return camera; + + device.depthNear = camera.near; + device.depthFar = camera.far; + + device.getFrameData( frameData ); + + // + + var pose = frameData.pose; + var poseObject = poseTarget !== null ? poseTarget : camera; + + if ( pose.position !== null ) { + + poseObject.position.fromArray( pose.position ); + + } else { + + poseObject.position.set( 0, 0, 0 ); + + } + + if ( pose.orientation !== null ) { + + poseObject.quaternion.fromArray( pose.orientation ); + + } + + poseObject.updateMatrixWorld(); + + if ( device.isPresenting === false ) return camera; + + // + + cameraL.near = camera.near; + cameraR.near = camera.near; + + cameraL.far = camera.far; + cameraR.far = camera.far; + + cameraVR.matrixWorld.copy( camera.matrixWorld ); + cameraVR.matrixWorldInverse.copy( camera.matrixWorldInverse ); + + cameraL.matrixWorldInverse.fromArray( frameData.leftViewMatrix ); + cameraR.matrixWorldInverse.fromArray( frameData.rightViewMatrix ); + + var parent = poseObject.parent; + + if ( parent !== null ) { + + matrixWorldInverse.getInverse( parent.matrixWorld ); + + cameraL.matrixWorldInverse.multiply( matrixWorldInverse ); + cameraR.matrixWorldInverse.multiply( matrixWorldInverse ); + + } + + // envMap and Mirror needs camera.matrixWorld + + cameraL.matrixWorld.getInverse( cameraL.matrixWorldInverse ); + cameraR.matrixWorld.getInverse( cameraR.matrixWorldInverse ); + + cameraL.projectionMatrix.fromArray( frameData.leftProjectionMatrix ); + cameraR.projectionMatrix.fromArray( frameData.rightProjectionMatrix ); + + // HACK @mrdoob + // https://github.com/w3c/webvr/issues/203 + + cameraVR.projectionMatrix.copy( cameraL.projectionMatrix ); + + // + + var layers = device.getLayers(); + + if ( layers.length ) { + + var layer = layers[ 0 ]; + + if ( layer.leftBounds !== null && layer.leftBounds.length === 4 ) { + + cameraL.bounds.fromArray( layer.leftBounds ); + + } + + if ( layer.rightBounds !== null && layer.rightBounds.length === 4 ) { + + cameraR.bounds.fromArray( layer.rightBounds ); + + } + + } + + return cameraVR; + + }; + + this.submitFrame = function () { + + if ( device && device.isPresenting ) device.submitFrame(); + + }; + + this.dispose = function () { + + if ( typeof window !== 'undefined' ) { + + window.removeEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange ); + + } + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function WebGLExtensions( gl ) { + + var extensions = {}; + + return { + + get: function ( name ) { + + if ( extensions[ name ] !== undefined ) { + + return extensions[ name ]; + + } + + var extension; + + switch ( name ) { + + case 'WEBGL_depth_texture': + extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' ); + break; + + case 'EXT_texture_filter_anisotropic': + extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' ); + break; + + case 'WEBGL_compressed_texture_s3tc': + extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' ); + break; + + case 'WEBGL_compressed_texture_pvrtc': + extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' ); + break; + + case 'WEBGL_compressed_texture_etc1': + extension = gl.getExtension( 'WEBGL_compressed_texture_etc1' ); + break; + + default: + extension = gl.getExtension( name ); + + } + + if ( extension === null ) { + + console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' ); + + } + + extensions[ name ] = extension; + + return extension; + + } + + }; + + } + + /** + * @author tschw + */ + + function WebGLClipping() { + + var scope = this, + + globalState = null, + numGlobalPlanes = 0, + localClippingEnabled = false, + renderingShadows = false, + + plane = new Plane(), + viewNormalMatrix = new Matrix3(), + + uniform = { value: null, needsUpdate: false }; + + this.uniform = uniform; + this.numPlanes = 0; + this.numIntersection = 0; + + this.init = function ( planes, enableLocalClipping, camera ) { + + var enabled = + planes.length !== 0 || + enableLocalClipping || + // enable state of previous frame - the clipping code has to + // run another frame in order to reset the state: + numGlobalPlanes !== 0 || + localClippingEnabled; + + localClippingEnabled = enableLocalClipping; + + globalState = projectPlanes( planes, camera, 0 ); + numGlobalPlanes = planes.length; + + return enabled; + + }; + + this.beginShadows = function () { + + renderingShadows = true; + projectPlanes( null ); + + }; + + this.endShadows = function () { + + renderingShadows = false; + resetGlobalState(); + + }; + + this.setState = function ( planes, clipIntersection, clipShadows, camera, cache, fromCache ) { + + if ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) { + + // there's no local clipping + + if ( renderingShadows ) { + + // there's no global clipping + + projectPlanes( null ); + + } else { + + resetGlobalState(); + + } + + } else { + + var nGlobal = renderingShadows ? 0 : numGlobalPlanes, + lGlobal = nGlobal * 4, + + dstArray = cache.clippingState || null; + + uniform.value = dstArray; // ensure unique state + + dstArray = projectPlanes( planes, camera, lGlobal, fromCache ); + + for ( var i = 0; i !== lGlobal; ++ i ) { + + dstArray[ i ] = globalState[ i ]; + + } + + cache.clippingState = dstArray; + this.numIntersection = clipIntersection ? this.numPlanes : 0; + this.numPlanes += nGlobal; + + } + + + }; + + function resetGlobalState() { + + if ( uniform.value !== globalState ) { + + uniform.value = globalState; + uniform.needsUpdate = numGlobalPlanes > 0; + + } + + scope.numPlanes = numGlobalPlanes; + scope.numIntersection = 0; + + } + + function projectPlanes( planes, camera, dstOffset, skipTransform ) { + + var nPlanes = planes !== null ? planes.length : 0, + dstArray = null; + + if ( nPlanes !== 0 ) { + + dstArray = uniform.value; + + if ( skipTransform !== true || dstArray === null ) { + + var flatSize = dstOffset + nPlanes * 4, + viewMatrix = camera.matrixWorldInverse; + + viewNormalMatrix.getNormalMatrix( viewMatrix ); + + if ( dstArray === null || dstArray.length < flatSize ) { + + dstArray = new Float32Array( flatSize ); + + } + + for ( var i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) { + + plane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix ); + + plane.normal.toArray( dstArray, i4 ); + dstArray[ i4 + 3 ] = plane.constant; + + } + + } + + uniform.value = dstArray; + uniform.needsUpdate = true; + + } + + scope.numPlanes = nPlanes; + + return dstArray; + + } + + } + + /** + * @author thespite / http://www.twitter.com/thespite + */ + + function WebGLUtils( gl, extensions ) { + + function convert( p ) { + + var extension; + + if ( p === RepeatWrapping ) return gl.REPEAT; + if ( p === ClampToEdgeWrapping ) return gl.CLAMP_TO_EDGE; + if ( p === MirroredRepeatWrapping ) return gl.MIRRORED_REPEAT; + + if ( p === NearestFilter ) return gl.NEAREST; + if ( p === NearestMipMapNearestFilter ) return gl.NEAREST_MIPMAP_NEAREST; + if ( p === NearestMipMapLinearFilter ) return gl.NEAREST_MIPMAP_LINEAR; + + if ( p === LinearFilter ) return gl.LINEAR; + if ( p === LinearMipMapNearestFilter ) return gl.LINEAR_MIPMAP_NEAREST; + if ( p === LinearMipMapLinearFilter ) return gl.LINEAR_MIPMAP_LINEAR; + + if ( p === UnsignedByteType ) return gl.UNSIGNED_BYTE; + if ( p === UnsignedShort4444Type ) return gl.UNSIGNED_SHORT_4_4_4_4; + if ( p === UnsignedShort5551Type ) return gl.UNSIGNED_SHORT_5_5_5_1; + if ( p === UnsignedShort565Type ) return gl.UNSIGNED_SHORT_5_6_5; + + if ( p === ByteType ) return gl.BYTE; + if ( p === ShortType ) return gl.SHORT; + if ( p === UnsignedShortType ) return gl.UNSIGNED_SHORT; + if ( p === IntType ) return gl.INT; + if ( p === UnsignedIntType ) return gl.UNSIGNED_INT; + if ( p === FloatType ) return gl.FLOAT; + + if ( p === HalfFloatType ) { + + extension = extensions.get( 'OES_texture_half_float' ); + + if ( extension !== null ) return extension.HALF_FLOAT_OES; + + } + + if ( p === AlphaFormat ) return gl.ALPHA; + if ( p === RGBFormat ) return gl.RGB; + if ( p === RGBAFormat ) return gl.RGBA; + if ( p === LuminanceFormat ) return gl.LUMINANCE; + if ( p === LuminanceAlphaFormat ) return gl.LUMINANCE_ALPHA; + if ( p === DepthFormat ) return gl.DEPTH_COMPONENT; + if ( p === DepthStencilFormat ) return gl.DEPTH_STENCIL; + + if ( p === AddEquation ) return gl.FUNC_ADD; + if ( p === SubtractEquation ) return gl.FUNC_SUBTRACT; + if ( p === ReverseSubtractEquation ) return gl.FUNC_REVERSE_SUBTRACT; + + if ( p === ZeroFactor ) return gl.ZERO; + if ( p === OneFactor ) return gl.ONE; + if ( p === SrcColorFactor ) return gl.SRC_COLOR; + if ( p === OneMinusSrcColorFactor ) return gl.ONE_MINUS_SRC_COLOR; + if ( p === SrcAlphaFactor ) return gl.SRC_ALPHA; + if ( p === OneMinusSrcAlphaFactor ) return gl.ONE_MINUS_SRC_ALPHA; + if ( p === DstAlphaFactor ) return gl.DST_ALPHA; + if ( p === OneMinusDstAlphaFactor ) return gl.ONE_MINUS_DST_ALPHA; + + if ( p === DstColorFactor ) return gl.DST_COLOR; + if ( p === OneMinusDstColorFactor ) return gl.ONE_MINUS_DST_COLOR; + if ( p === SrcAlphaSaturateFactor ) return gl.SRC_ALPHA_SATURATE; + + if ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || + p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) { + + extension = extensions.get( 'WEBGL_compressed_texture_s3tc' ); + + if ( extension !== null ) { + + if ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT; + if ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT; + if ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT; + if ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT; + + } + + } + + if ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || + p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) { + + extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' ); + + if ( extension !== null ) { + + if ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + if ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + if ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + if ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + + } + + } + + if ( p === RGB_ETC1_Format ) { + + extension = extensions.get( 'WEBGL_compressed_texture_etc1' ); + + if ( extension !== null ) return extension.COMPRESSED_RGB_ETC1_WEBGL; + + } + + if ( p === MinEquation || p === MaxEquation ) { + + extension = extensions.get( 'EXT_blend_minmax' ); + + if ( extension !== null ) { + + if ( p === MinEquation ) return extension.MIN_EXT; + if ( p === MaxEquation ) return extension.MAX_EXT; + + } + + } + + if ( p === UnsignedInt248Type ) { + + extension = extensions.get( 'WEBGL_depth_texture' ); + + if ( extension !== null ) return extension.UNSIGNED_INT_24_8_WEBGL; + + } + + return 0; + + } + + return { convert: convert }; + + } + + /** + * @author supereggbert / http://www.paulbrunt.co.uk/ + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * @author szimek / https://github.com/szimek/ + * @author tschw + */ + + function WebGLRenderer( parameters ) { + + console.log( 'THREE.WebGLRenderer', REVISION ); + + parameters = parameters || {}; + + var _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ), + _context = parameters.context !== undefined ? parameters.context : null, + + _alpha = parameters.alpha !== undefined ? parameters.alpha : false, + _depth = parameters.depth !== undefined ? parameters.depth : true, + _stencil = parameters.stencil !== undefined ? parameters.stencil : true, + _antialias = parameters.antialias !== undefined ? parameters.antialias : false, + _premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true, + _preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false, + _powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default'; + + var lightsArray = []; + var shadowsArray = []; + + var currentRenderList = null; + + var spritesArray = []; + var flaresArray = []; + + // public properties + + this.domElement = _canvas; + this.context = null; + + // clearing + + this.autoClear = true; + this.autoClearColor = true; + this.autoClearDepth = true; + this.autoClearStencil = true; + + // scene graph + + this.sortObjects = true; + + // user-defined clipping + + this.clippingPlanes = []; + this.localClippingEnabled = false; + + // physically based shading + + this.gammaFactor = 2.0; // for backwards compatibility + this.gammaInput = false; + this.gammaOutput = false; + + // physical lights + + this.physicallyCorrectLights = false; + + // tone mapping + + this.toneMapping = LinearToneMapping; + this.toneMappingExposure = 1.0; + this.toneMappingWhitePoint = 1.0; + + // morphs + + this.maxMorphTargets = 8; + this.maxMorphNormals = 4; + + // internal properties + + var _this = this, + + _isContextLost = false, + + // internal state cache + + _currentRenderTarget = null, + _currentFramebuffer = null, + _currentMaterialId = - 1, + _currentGeometryProgram = '', + + _currentCamera = null, + _currentArrayCamera = null, + + _currentViewport = new Vector4(), + _currentScissor = new Vector4(), + _currentScissorTest = null, + + // + + _usedTextureUnits = 0, + + // + + _width = _canvas.width, + _height = _canvas.height, + + _pixelRatio = 1, + + _viewport = new Vector4( 0, 0, _width, _height ), + _scissor = new Vector4( 0, 0, _width, _height ), + _scissorTest = false, + + // frustum + + _frustum = new Frustum(), + + // clipping + + _clipping = new WebGLClipping(), + _clippingEnabled = false, + _localClippingEnabled = false, + + // camera matrices cache + + _projScreenMatrix = new Matrix4(), + + _vector3 = new Vector3(), + + // info + + _infoMemory = { + geometries: 0, + textures: 0 + }, + + _infoRender = { + + frame: 0, + calls: 0, + vertices: 0, + faces: 0, + points: 0 + + }; + + this.info = { + + render: _infoRender, + memory: _infoMemory, + programs: null + + }; + + function getTargetPixelRatio() { + + return _currentRenderTarget === null ? _pixelRatio : 1; + + } + + // initialize + + var _gl; + + try { + + var contextAttributes = { + alpha: _alpha, + depth: _depth, + stencil: _stencil, + antialias: _antialias, + premultipliedAlpha: _premultipliedAlpha, + preserveDrawingBuffer: _preserveDrawingBuffer, + powerPreference: _powerPreference + }; + + // event listeners must be registered before WebGL context is created, see #12753 + + _canvas.addEventListener( 'webglcontextlost', onContextLost, false ); + _canvas.addEventListener( 'webglcontextrestored', onContextRestore, false ); + + _gl = _context || _canvas.getContext( 'webgl', contextAttributes ) || _canvas.getContext( 'experimental-webgl', contextAttributes ); + + if ( _gl === null ) { + + if ( _canvas.getContext( 'webgl' ) !== null ) { + + throw new Error( 'Error creating WebGL context with your selected attributes.' ); + + } else { + + throw new Error( 'Error creating WebGL context.' ); + + } + + } + + // Some experimental-webgl implementations do not have getShaderPrecisionFormat + + if ( _gl.getShaderPrecisionFormat === undefined ) { + + _gl.getShaderPrecisionFormat = function () { + + return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 }; + + }; + + } + + } catch ( error ) { + + console.error( 'THREE.WebGLRenderer: ' + error.message ); + + } + + var extensions, capabilities, state; + var properties, textures, attributes, geometries, objects, lights; + var programCache, renderLists; + + var background, morphtargets, bufferRenderer, indexedBufferRenderer; + var flareRenderer, spriteRenderer; + + var utils; + + function initGLContext() { + + extensions = new WebGLExtensions( _gl ); + extensions.get( 'WEBGL_depth_texture' ); + extensions.get( 'OES_texture_float' ); + extensions.get( 'OES_texture_float_linear' ); + extensions.get( 'OES_texture_half_float' ); + extensions.get( 'OES_texture_half_float_linear' ); + extensions.get( 'OES_standard_derivatives' ); + extensions.get( 'OES_element_index_uint' ); + extensions.get( 'ANGLE_instanced_arrays' ); + + utils = new WebGLUtils( _gl, extensions ); + + capabilities = new WebGLCapabilities( _gl, extensions, parameters ); + + state = new WebGLState( _gl, extensions, utils ); + state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) ); + state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) ); + + properties = new WebGLProperties(); + textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, _infoMemory ); + attributes = new WebGLAttributes( _gl ); + geometries = new WebGLGeometries( _gl, attributes, _infoMemory ); + objects = new WebGLObjects( geometries, _infoRender ); + morphtargets = new WebGLMorphtargets( _gl ); + programCache = new WebGLPrograms( _this, extensions, capabilities ); + lights = new WebGLLights(); + renderLists = new WebGLRenderLists(); + + background = new WebGLBackground( _this, state, geometries, _premultipliedAlpha ); + + bufferRenderer = new WebGLBufferRenderer( _gl, extensions, _infoRender ); + indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, _infoRender ); + + flareRenderer = new WebGLFlareRenderer( _this, _gl, state, textures, capabilities ); + spriteRenderer = new WebGLSpriteRenderer( _this, _gl, state, textures, capabilities ); + + _this.info.programs = programCache.programs; + + _this.context = _gl; + _this.capabilities = capabilities; + _this.extensions = extensions; + _this.properties = properties; + _this.renderLists = renderLists; + _this.state = state; + + } + + initGLContext(); + + // vr + + var vr = new WebVRManager( _this ); + + this.vr = vr; + + // shadow map + + var shadowMap = new WebGLShadowMap( _this, objects, capabilities.maxTextureSize ); + + this.shadowMap = shadowMap; + + // API + + this.getContext = function () { + + return _gl; + + }; + + this.getContextAttributes = function () { + + return _gl.getContextAttributes(); + + }; + + this.forceContextLoss = function () { + + var extension = extensions.get( 'WEBGL_lose_context' ); + if ( extension ) extension.loseContext(); + + }; + + this.forceContextRestore = function () { + + var extension = extensions.get( 'WEBGL_lose_context' ); + if ( extension ) extension.restoreContext(); + + }; + + this.getPixelRatio = function () { + + return _pixelRatio; + + }; + + this.setPixelRatio = function ( value ) { + + if ( value === undefined ) return; + + _pixelRatio = value; + + this.setSize( _width, _height, false ); + + }; + + this.getSize = function () { + + return { + width: _width, + height: _height + }; + + }; + + this.setSize = function ( width, height, updateStyle ) { + + var device = vr.getDevice(); + + if ( device && device.isPresenting ) { + + console.warn( 'THREE.WebGLRenderer: Can\'t change size while VR device is presenting.' ); + return; + + } + + _width = width; + _height = height; + + _canvas.width = width * _pixelRatio; + _canvas.height = height * _pixelRatio; + + if ( updateStyle !== false ) { + + _canvas.style.width = width + 'px'; + _canvas.style.height = height + 'px'; + + } + + this.setViewport( 0, 0, width, height ); + + }; + + this.getDrawingBufferSize = function () { + + return { + width: _width * _pixelRatio, + height: _height * _pixelRatio + }; + + }; + + this.setDrawingBufferSize = function ( width, height, pixelRatio ) { + + _width = width; + _height = height; + + _pixelRatio = pixelRatio; + + _canvas.width = width * pixelRatio; + _canvas.height = height * pixelRatio; + + this.setViewport( 0, 0, width, height ); + + }; + + this.setViewport = function ( x, y, width, height ) { + + _viewport.set( x, _height - y - height, width, height ); + state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) ); + + }; + + this.setScissor = function ( x, y, width, height ) { + + _scissor.set( x, _height - y - height, width, height ); + state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) ); + + }; + + this.setScissorTest = function ( boolean ) { + + state.setScissorTest( _scissorTest = boolean ); + + }; + + // Clearing + + this.getClearColor = function () { + + return background.getClearColor(); + + }; + + this.setClearColor = function () { + + background.setClearColor.apply( background, arguments ); + + }; + + this.getClearAlpha = function () { + + return background.getClearAlpha(); + + }; + + this.setClearAlpha = function () { + + background.setClearAlpha.apply( background, arguments ); + + }; + + this.clear = function ( color, depth, stencil ) { + + var bits = 0; + + if ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT; + if ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT; + if ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT; + + _gl.clear( bits ); + + }; + + this.clearColor = function () { + + this.clear( true, false, false ); + + }; + + this.clearDepth = function () { + + this.clear( false, true, false ); + + }; + + this.clearStencil = function () { + + this.clear( false, false, true ); + + }; + + this.clearTarget = function ( renderTarget, color, depth, stencil ) { + + this.setRenderTarget( renderTarget ); + this.clear( color, depth, stencil ); + + }; + + // + + this.dispose = function () { + + _canvas.removeEventListener( 'webglcontextlost', onContextLost, false ); + _canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false ); + + renderLists.dispose(); + + vr.dispose(); + + }; + + // Events + + function onContextLost( event ) { + + event.preventDefault(); + + console.log( 'THREE.WebGLRenderer: Context Lost.' ); + + _isContextLost = true; + + } + + function onContextRestore( /* event */ ) { + + console.log( 'THREE.WebGLRenderer: Context Restored.' ); + + _isContextLost = false; + + initGLContext(); + + } + + function onMaterialDispose( event ) { + + var material = event.target; + + material.removeEventListener( 'dispose', onMaterialDispose ); + + deallocateMaterial( material ); + + } + + // Buffer deallocation + + function deallocateMaterial( material ) { + + releaseMaterialProgramReference( material ); + + properties.remove( material ); + + } + + + function releaseMaterialProgramReference( material ) { + + var programInfo = properties.get( material ).program; + + material.program = undefined; + + if ( programInfo !== undefined ) { + + programCache.releaseProgram( programInfo ); + + } + + } + + // Buffer rendering + + function renderObjectImmediate( object, program, material ) { + + object.render( function ( object ) { + + _this.renderBufferImmediate( object, program, material ); + + } ); + + } + + this.renderBufferImmediate = function ( object, program, material ) { + + state.initAttributes(); + + var buffers = properties.get( object ); + + if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer(); + if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer(); + if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer(); + if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer(); + + var programAttributes = program.getAttributes(); + + if ( object.hasPositions ) { + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position ); + _gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW ); + + state.enableAttribute( programAttributes.position ); + _gl.vertexAttribPointer( programAttributes.position, 3, _gl.FLOAT, false, 0, 0 ); + + } + + if ( object.hasNormals ) { + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal ); + + if ( ! material.isMeshPhongMaterial && + ! material.isMeshStandardMaterial && + ! material.isMeshNormalMaterial && + material.flatShading === true ) { + + for ( var i = 0, l = object.count * 3; i < l; i += 9 ) { + + var array = object.normalArray; + + var nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3; + var ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3; + var nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3; + + array[ i + 0 ] = nx; + array[ i + 1 ] = ny; + array[ i + 2 ] = nz; + + array[ i + 3 ] = nx; + array[ i + 4 ] = ny; + array[ i + 5 ] = nz; + + array[ i + 6 ] = nx; + array[ i + 7 ] = ny; + array[ i + 8 ] = nz; + + } + + } + + _gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW ); + + state.enableAttribute( programAttributes.normal ); + + _gl.vertexAttribPointer( programAttributes.normal, 3, _gl.FLOAT, false, 0, 0 ); + + } + + if ( object.hasUvs && material.map ) { + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv ); + _gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW ); + + state.enableAttribute( programAttributes.uv ); + + _gl.vertexAttribPointer( programAttributes.uv, 2, _gl.FLOAT, false, 0, 0 ); + + } + + if ( object.hasColors && material.vertexColors !== NoColors ) { + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color ); + _gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW ); + + state.enableAttribute( programAttributes.color ); + + _gl.vertexAttribPointer( programAttributes.color, 3, _gl.FLOAT, false, 0, 0 ); + + } + + state.disableUnusedAttributes(); + + _gl.drawArrays( _gl.TRIANGLES, 0, object.count ); + + object.count = 0; + + }; + + this.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) { + + var frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 ); + + state.setMaterial( material, frontFaceCW ); + + var program = setProgram( camera, fog, material, object ); + var geometryProgram = geometry.id + '_' + program.id + '_' + ( material.wireframe === true ); + + var updateBuffers = false; + + if ( geometryProgram !== _currentGeometryProgram ) { + + _currentGeometryProgram = geometryProgram; + updateBuffers = true; + + } + + if ( object.morphTargetInfluences ) { + + morphtargets.update( object, geometry, material, program ); + + updateBuffers = true; + + } + + // + + var index = geometry.index; + var position = geometry.attributes.position; + var rangeFactor = 1; + + if ( material.wireframe === true ) { + + index = geometries.getWireframeAttribute( geometry ); + rangeFactor = 2; + + } + + var attribute; + var renderer = bufferRenderer; + + if ( index !== null ) { + + attribute = attributes.get( index ); + + renderer = indexedBufferRenderer; + renderer.setIndex( attribute ); + + } + + if ( updateBuffers ) { + + setupVertexAttributes( material, program, geometry ); + + if ( index !== null ) { + + _gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, attribute.buffer ); + + } + + } + + // + + var dataCount = 0; + + if ( index !== null ) { + + dataCount = index.count; + + } else if ( position !== undefined ) { + + dataCount = position.count; + + } + + var rangeStart = geometry.drawRange.start * rangeFactor; + var rangeCount = geometry.drawRange.count * rangeFactor; + + var groupStart = group !== null ? group.start * rangeFactor : 0; + var groupCount = group !== null ? group.count * rangeFactor : Infinity; + + var drawStart = Math.max( rangeStart, groupStart ); + var drawEnd = Math.min( dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1; + + var drawCount = Math.max( 0, drawEnd - drawStart + 1 ); + + if ( drawCount === 0 ) return; + + // + + if ( object.isMesh ) { + + if ( material.wireframe === true ) { + + state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() ); + renderer.setMode( _gl.LINES ); + + } else { + + switch ( object.drawMode ) { + + case TrianglesDrawMode: + renderer.setMode( _gl.TRIANGLES ); + break; + + case TriangleStripDrawMode: + renderer.setMode( _gl.TRIANGLE_STRIP ); + break; + + case TriangleFanDrawMode: + renderer.setMode( _gl.TRIANGLE_FAN ); + break; + + } + + } + + + } else if ( object.isLine ) { + + var lineWidth = material.linewidth; + + if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material + + state.setLineWidth( lineWidth * getTargetPixelRatio() ); + + if ( object.isLineSegments ) { + + renderer.setMode( _gl.LINES ); + + } else if ( object.isLineLoop ) { + + renderer.setMode( _gl.LINE_LOOP ); + + } else { + + renderer.setMode( _gl.LINE_STRIP ); + + } + + } else if ( object.isPoints ) { + + renderer.setMode( _gl.POINTS ); + + } + + if ( geometry && geometry.isInstancedBufferGeometry ) { + + if ( geometry.maxInstancedCount > 0 ) { + + renderer.renderInstances( geometry, drawStart, drawCount ); + + } + + } else { + + renderer.render( drawStart, drawCount ); + + } + + }; + + function setupVertexAttributes( material, program, geometry, startIndex ) { + + if ( geometry && geometry.isInstancedBufferGeometry ) { + + if ( extensions.get( 'ANGLE_instanced_arrays' ) === null ) { + + console.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); + return; + + } + + } + + if ( startIndex === undefined ) startIndex = 0; + + state.initAttributes(); + + var geometryAttributes = geometry.attributes; + + var programAttributes = program.getAttributes(); + + var materialDefaultAttributeValues = material.defaultAttributeValues; + + for ( var name in programAttributes ) { + + var programAttribute = programAttributes[ name ]; + + if ( programAttribute >= 0 ) { + + var geometryAttribute = geometryAttributes[ name ]; + + if ( geometryAttribute !== undefined ) { + + var normalized = geometryAttribute.normalized; + var size = geometryAttribute.itemSize; + + var attribute = attributes.get( geometryAttribute ); + + // TODO Attribute may not be available on context restore + + if ( attribute === undefined ) continue; + + var buffer = attribute.buffer; + var type = attribute.type; + var bytesPerElement = attribute.bytesPerElement; + + if ( geometryAttribute.isInterleavedBufferAttribute ) { + + var data = geometryAttribute.data; + var stride = data.stride; + var offset = geometryAttribute.offset; + + if ( data && data.isInstancedInterleavedBuffer ) { + + state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute ); + + if ( geometry.maxInstancedCount === undefined ) { + + geometry.maxInstancedCount = data.meshPerAttribute * data.count; + + } + + } else { + + state.enableAttribute( programAttribute ); + + } + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffer ); + _gl.vertexAttribPointer( programAttribute, size, type, normalized, stride * bytesPerElement, ( startIndex * stride + offset ) * bytesPerElement ); + + } else { + + if ( geometryAttribute.isInstancedBufferAttribute ) { + + state.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute ); + + if ( geometry.maxInstancedCount === undefined ) { + + geometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count; + + } + + } else { + + state.enableAttribute( programAttribute ); + + } + + _gl.bindBuffer( _gl.ARRAY_BUFFER, buffer ); + _gl.vertexAttribPointer( programAttribute, size, type, normalized, 0, startIndex * size * bytesPerElement ); + + } + + } else if ( materialDefaultAttributeValues !== undefined ) { + + var value = materialDefaultAttributeValues[ name ]; + + if ( value !== undefined ) { + + switch ( value.length ) { + + case 2: + _gl.vertexAttrib2fv( programAttribute, value ); + break; + + case 3: + _gl.vertexAttrib3fv( programAttribute, value ); + break; + + case 4: + _gl.vertexAttrib4fv( programAttribute, value ); + break; + + default: + _gl.vertexAttrib1fv( programAttribute, value ); + + } + + } + + } + + } + + } + + state.disableUnusedAttributes(); + + } + + // Compile + + this.compile = function ( scene, camera ) { + + lightsArray.length = 0; + shadowsArray.length = 0; + + scene.traverse( function ( object ) { + + if ( object.isLight ) { + + lightsArray.push( object ); + + if ( object.castShadow ) { + + shadowsArray.push( object ); + + } + + } + + } ); + + lights.setup( lightsArray, shadowsArray, camera ); + + scene.traverse( function ( object ) { + + if ( object.material ) { + + if ( Array.isArray( object.material ) ) { + + for ( var i = 0; i < object.material.length; i ++ ) { + + initMaterial( object.material[ i ], scene.fog, object ); + + } + + } else { + + initMaterial( object.material, scene.fog, object ); + + } + + } + + } ); + + }; + + // Animation Loop + + var isAnimating = false; + var onAnimationFrame = null; + + function start() { + + if ( isAnimating ) return; + + var device = vr.getDevice(); + + if ( device && device.isPresenting ) { + + device.requestAnimationFrame( loop ); + + } else { + + window.requestAnimationFrame( loop ); + + } + + isAnimating = true; + + } + + function loop( time ) { + + if ( onAnimationFrame !== null ) onAnimationFrame( time ); + + var device = vr.getDevice(); + + if ( device && device.isPresenting ) { + + device.requestAnimationFrame( loop ); + + } else { + + window.requestAnimationFrame( loop ); + + } + + } + + this.animate = function ( callback ) { + + onAnimationFrame = callback; + start(); + + }; + + // Rendering + + this.render = function ( scene, camera, renderTarget, forceClear ) { + + if ( ! ( camera && camera.isCamera ) ) { + + console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' ); + return; + + } + + if ( _isContextLost ) return; + + // reset caching for this frame + + _currentGeometryProgram = ''; + _currentMaterialId = - 1; + _currentCamera = null; + + // update scene graph + + if ( scene.autoUpdate === true ) scene.updateMatrixWorld(); + + // update camera matrices and frustum + + if ( camera.parent === null ) camera.updateMatrixWorld(); + + if ( vr.enabled ) { + + camera = vr.getCamera( camera ); + + } + + _projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse ); + _frustum.setFromMatrix( _projScreenMatrix ); + + lightsArray.length = 0; + shadowsArray.length = 0; + + spritesArray.length = 0; + flaresArray.length = 0; + + _localClippingEnabled = this.localClippingEnabled; + _clippingEnabled = _clipping.init( this.clippingPlanes, _localClippingEnabled, camera ); + + currentRenderList = renderLists.get( scene, camera ); + currentRenderList.init(); + + projectObject( scene, camera, _this.sortObjects ); + + if ( _this.sortObjects === true ) { + + currentRenderList.sort(); + + } + + // + + textures.updateVideoTextures(); + + // + + if ( _clippingEnabled ) _clipping.beginShadows(); + + shadowMap.render( shadowsArray, scene, camera ); + + lights.setup( lightsArray, shadowsArray, camera ); + + if ( _clippingEnabled ) _clipping.endShadows(); + + // + + _infoRender.frame ++; + _infoRender.calls = 0; + _infoRender.vertices = 0; + _infoRender.faces = 0; + _infoRender.points = 0; + + if ( renderTarget === undefined ) { + + renderTarget = null; + + } + + this.setRenderTarget( renderTarget ); + + // + + background.render( currentRenderList, scene, camera, forceClear ); + + // render scene + + var opaqueObjects = currentRenderList.opaque; + var transparentObjects = currentRenderList.transparent; + + if ( scene.overrideMaterial ) { + + var overrideMaterial = scene.overrideMaterial; + + if ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera, overrideMaterial ); + if ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera, overrideMaterial ); + + } else { + + // opaque pass (front-to-back order) + + if ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera ); + + // transparent pass (back-to-front order) + + if ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera ); + + } + + // custom renderers + + spriteRenderer.render( spritesArray, scene, camera ); + flareRenderer.render( flaresArray, scene, camera, _currentViewport ); + + // Generate mipmap if we're using any kind of mipmap filtering + + if ( renderTarget ) { + + textures.updateRenderTargetMipmap( renderTarget ); + + } + + // Ensure depth buffer writing is enabled so it can be cleared on next render + + state.buffers.depth.setTest( true ); + state.buffers.depth.setMask( true ); + state.buffers.color.setMask( true ); + + state.setPolygonOffset( false ); + + if ( vr.enabled ) { + + vr.submitFrame(); + + } + + // _gl.finish(); + + }; + + /* + // TODO Duplicated code (Frustum) + + var _sphere = new Sphere(); + + function isObjectViewable( object ) { + + var geometry = object.geometry; + + if ( geometry.boundingSphere === null ) + geometry.computeBoundingSphere(); + + _sphere.copy( geometry.boundingSphere ). + applyMatrix4( object.matrixWorld ); + + return isSphereViewable( _sphere ); + + } + + function isSpriteViewable( sprite ) { + + _sphere.center.set( 0, 0, 0 ); + _sphere.radius = 0.7071067811865476; + _sphere.applyMatrix4( sprite.matrixWorld ); + + return isSphereViewable( _sphere ); + + } + + function isSphereViewable( sphere ) { + + if ( ! _frustum.intersectsSphere( sphere ) ) return false; + + var numPlanes = _clipping.numPlanes; + + if ( numPlanes === 0 ) return true; + + var planes = _this.clippingPlanes, + + center = sphere.center, + negRad = - sphere.radius, + i = 0; + + do { + + // out when deeper than radius in the negative halfspace + if ( planes[ i ].distanceToPoint( center ) < negRad ) return false; + + } while ( ++ i !== numPlanes ); + + return true; + + } + */ + + function projectObject( object, camera, sortObjects ) { + + if ( object.visible === false ) return; + + var visible = object.layers.test( camera.layers ); + + if ( visible ) { + + if ( object.isLight ) { + + lightsArray.push( object ); + + if ( object.castShadow ) { + + shadowsArray.push( object ); + + } + + } else if ( object.isSprite ) { + + if ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) { + + spritesArray.push( object ); + + } + + } else if ( object.isLensFlare ) { + + flaresArray.push( object ); + + } else if ( object.isImmediateRenderObject ) { + + if ( sortObjects ) { + + _vector3.setFromMatrixPosition( object.matrixWorld ) + .applyMatrix4( _projScreenMatrix ); + + } + + currentRenderList.push( object, null, object.material, _vector3.z, null ); + + } else if ( object.isMesh || object.isLine || object.isPoints ) { + + if ( object.isSkinnedMesh ) { + + object.skeleton.update(); + + } + + if ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) { + + if ( sortObjects ) { + + _vector3.setFromMatrixPosition( object.matrixWorld ) + .applyMatrix4( _projScreenMatrix ); + + } + + var geometry = objects.update( object ); + var material = object.material; + + if ( Array.isArray( material ) ) { + + var groups = geometry.groups; + + for ( var i = 0, l = groups.length; i < l; i ++ ) { + + var group = groups[ i ]; + var groupMaterial = material[ group.materialIndex ]; + + if ( groupMaterial && groupMaterial.visible ) { + + currentRenderList.push( object, geometry, groupMaterial, _vector3.z, group ); + + } + + } + + } else if ( material.visible ) { + + currentRenderList.push( object, geometry, material, _vector3.z, null ); + + } + + } + + } + + } + + var children = object.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + projectObject( children[ i ], camera, sortObjects ); + + } + + } + + function renderObjects( renderList, scene, camera, overrideMaterial ) { + + for ( var i = 0, l = renderList.length; i < l; i ++ ) { + + var renderItem = renderList[ i ]; + + var object = renderItem.object; + var geometry = renderItem.geometry; + var material = overrideMaterial === undefined ? renderItem.material : overrideMaterial; + var group = renderItem.group; + + if ( camera.isArrayCamera ) { + + _currentArrayCamera = camera; + + var cameras = camera.cameras; + + for ( var j = 0, jl = cameras.length; j < jl; j ++ ) { + + var camera2 = cameras[ j ]; + + if ( object.layers.test( camera2.layers ) ) { + + var bounds = camera2.bounds; + + var x = bounds.x * _width; + var y = bounds.y * _height; + var width = bounds.z * _width; + var height = bounds.w * _height; + + state.viewport( _currentViewport.set( x, y, width, height ).multiplyScalar( _pixelRatio ) ); + + renderObject( object, scene, camera2, geometry, material, group ); + + } + + } + + } else { + + _currentArrayCamera = null; + + renderObject( object, scene, camera, geometry, material, group ); + + } + + } + + } + + function renderObject( object, scene, camera, geometry, material, group ) { + + object.onBeforeRender( _this, scene, camera, geometry, material, group ); + + object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld ); + object.normalMatrix.getNormalMatrix( object.modelViewMatrix ); + + if ( object.isImmediateRenderObject ) { + + var frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 ); + + state.setMaterial( material, frontFaceCW ); + + var program = setProgram( camera, scene.fog, material, object ); + + _currentGeometryProgram = ''; + + renderObjectImmediate( object, program, material ); + + } else { + + _this.renderBufferDirect( camera, scene.fog, geometry, material, object, group ); + + } + + object.onAfterRender( _this, scene, camera, geometry, material, group ); + + } + + function initMaterial( material, fog, object ) { + + var materialProperties = properties.get( material ); + + var parameters = programCache.getParameters( + material, lights.state, shadowsArray, fog, _clipping.numPlanes, _clipping.numIntersection, object ); + + var code = programCache.getProgramCode( material, parameters ); + + var program = materialProperties.program; + var programChange = true; + + if ( program === undefined ) { + + // new material + material.addEventListener( 'dispose', onMaterialDispose ); + + } else if ( program.code !== code ) { + + // changed glsl or parameters + releaseMaterialProgramReference( material ); + + } else if ( parameters.shaderID !== undefined ) { + + // same glsl and uniform list + return; + + } else { + + // only rebuild uniform list + programChange = false; + + } + + if ( programChange ) { + + if ( parameters.shaderID ) { + + var shader = ShaderLib[ parameters.shaderID ]; + + materialProperties.shader = { + name: material.type, + uniforms: UniformsUtils.clone( shader.uniforms ), + vertexShader: shader.vertexShader, + fragmentShader: shader.fragmentShader + }; + + } else { + + materialProperties.shader = { + name: material.type, + uniforms: material.uniforms, + vertexShader: material.vertexShader, + fragmentShader: material.fragmentShader + }; + + } + + material.onBeforeCompile( materialProperties.shader ); + + program = programCache.acquireProgram( material, materialProperties.shader, parameters, code ); + + materialProperties.program = program; + material.program = program; + + } + + var programAttributes = program.getAttributes(); + + if ( material.morphTargets ) { + + material.numSupportedMorphTargets = 0; + + for ( var i = 0; i < _this.maxMorphTargets; i ++ ) { + + if ( programAttributes[ 'morphTarget' + i ] >= 0 ) { + + material.numSupportedMorphTargets ++; + + } + + } + + } + + if ( material.morphNormals ) { + + material.numSupportedMorphNormals = 0; + + for ( var i = 0; i < _this.maxMorphNormals; i ++ ) { + + if ( programAttributes[ 'morphNormal' + i ] >= 0 ) { + + material.numSupportedMorphNormals ++; + + } + + } + + } + + var uniforms = materialProperties.shader.uniforms; + + if ( ! material.isShaderMaterial && + ! material.isRawShaderMaterial || + material.clipping === true ) { + + materialProperties.numClippingPlanes = _clipping.numPlanes; + materialProperties.numIntersection = _clipping.numIntersection; + uniforms.clippingPlanes = _clipping.uniform; + + } + + materialProperties.fog = fog; + + // store the light setup it was created for + + materialProperties.lightsHash = lights.state.hash; + + if ( material.lights ) { + + // wire up the material to this renderer's lighting state + + uniforms.ambientLightColor.value = lights.state.ambient; + uniforms.directionalLights.value = lights.state.directional; + uniforms.spotLights.value = lights.state.spot; + uniforms.rectAreaLights.value = lights.state.rectArea; + uniforms.pointLights.value = lights.state.point; + uniforms.hemisphereLights.value = lights.state.hemi; + + uniforms.directionalShadowMap.value = lights.state.directionalShadowMap; + uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix; + uniforms.spotShadowMap.value = lights.state.spotShadowMap; + uniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix; + uniforms.pointShadowMap.value = lights.state.pointShadowMap; + uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix; + // TODO (abelnation): add area lights shadow info to uniforms + + } + + var progUniforms = materialProperties.program.getUniforms(), + uniformsList = + WebGLUniforms.seqWithValue( progUniforms.seq, uniforms ); + + materialProperties.uniformsList = uniformsList; + + } + + function setProgram( camera, fog, material, object ) { + + _usedTextureUnits = 0; + + var materialProperties = properties.get( material ); + + if ( _clippingEnabled ) { + + if ( _localClippingEnabled || camera !== _currentCamera ) { + + var useCache = + camera === _currentCamera && + material.id === _currentMaterialId; + + // we might want to call this function with some ClippingGroup + // object instead of the material, once it becomes feasible + // (#8465, #8379) + _clipping.setState( + material.clippingPlanes, material.clipIntersection, material.clipShadows, + camera, materialProperties, useCache ); + + } + + } + + if ( material.needsUpdate === false ) { + + if ( materialProperties.program === undefined ) { + + material.needsUpdate = true; + + } else if ( material.fog && materialProperties.fog !== fog ) { + + material.needsUpdate = true; + + } else if ( material.lights && materialProperties.lightsHash !== lights.state.hash ) { + + material.needsUpdate = true; + + } else if ( materialProperties.numClippingPlanes !== undefined && + ( materialProperties.numClippingPlanes !== _clipping.numPlanes || + materialProperties.numIntersection !== _clipping.numIntersection ) ) { + + material.needsUpdate = true; + + } + + } + + if ( material.needsUpdate ) { + + initMaterial( material, fog, object ); + material.needsUpdate = false; + + } + + var refreshProgram = false; + var refreshMaterial = false; + var refreshLights = false; + + var program = materialProperties.program, + p_uniforms = program.getUniforms(), + m_uniforms = materialProperties.shader.uniforms; + + if ( state.useProgram( program.program ) ) { + + refreshProgram = true; + refreshMaterial = true; + refreshLights = true; + + } + + if ( material.id !== _currentMaterialId ) { + + _currentMaterialId = material.id; + + refreshMaterial = true; + + } + + if ( refreshProgram || camera !== _currentCamera ) { + + p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix ); + + if ( capabilities.logarithmicDepthBuffer ) { + + p_uniforms.setValue( _gl, 'logDepthBufFC', + 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) ); + + } + + // Avoid unneeded uniform updates per ArrayCamera's sub-camera + + if ( _currentCamera !== ( _currentArrayCamera || camera ) ) { + + _currentCamera = ( _currentArrayCamera || camera ); + + // lighting uniforms depend on the camera so enforce an update + // now, in case this material supports lights - or later, when + // the next material that does gets activated: + + refreshMaterial = true; // set to true on material change + refreshLights = true; // remains set until update done + + } + + // load material specific uniforms + // (shader material also gets them for the sake of genericity) + + if ( material.isShaderMaterial || + material.isMeshPhongMaterial || + material.isMeshStandardMaterial || + material.envMap ) { + + var uCamPos = p_uniforms.map.cameraPosition; + + if ( uCamPos !== undefined ) { + + uCamPos.setValue( _gl, + _vector3.setFromMatrixPosition( camera.matrixWorld ) ); + + } + + } + + if ( material.isMeshPhongMaterial || + material.isMeshLambertMaterial || + material.isMeshBasicMaterial || + material.isMeshStandardMaterial || + material.isShaderMaterial || + material.skinning ) { + + p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse ); + + } + + } + + // skinning uniforms must be set even if material didn't change + // auto-setting of texture unit for bone texture must go before other textures + // not sure why, but otherwise weird things happen + + if ( material.skinning ) { + + p_uniforms.setOptional( _gl, object, 'bindMatrix' ); + p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' ); + + var skeleton = object.skeleton; + + if ( skeleton ) { + + var bones = skeleton.bones; + + if ( capabilities.floatVertexTextures ) { + + if ( skeleton.boneTexture === undefined ) { + + // layout (1 matrix = 4 pixels) + // RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4) + // with 8x8 pixel texture max 16 bones * 4 pixels = (8 * 8) + // 16x16 pixel texture max 64 bones * 4 pixels = (16 * 16) + // 32x32 pixel texture max 256 bones * 4 pixels = (32 * 32) + // 64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64) + + + var size = Math.sqrt( bones.length * 4 ); // 4 pixels needed for 1 matrix + size = _Math.ceilPowerOfTwo( size ); + size = Math.max( size, 4 ); + + var boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel + boneMatrices.set( skeleton.boneMatrices ); // copy current values + + var boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType ); + + skeleton.boneMatrices = boneMatrices; + skeleton.boneTexture = boneTexture; + skeleton.boneTextureSize = size; + + } + + p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture ); + p_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize ); + + } else { + + p_uniforms.setOptional( _gl, skeleton, 'boneMatrices' ); + + } + + } + + } + + if ( refreshMaterial ) { + + p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure ); + p_uniforms.setValue( _gl, 'toneMappingWhitePoint', _this.toneMappingWhitePoint ); + + if ( material.lights ) { + + // the current material requires lighting info + + // note: all lighting uniforms are always set correctly + // they simply reference the renderer's state for their + // values + // + // use the current material's .needsUpdate flags to set + // the GL state when required + + markUniformsLightsNeedsUpdate( m_uniforms, refreshLights ); + + } + + // refresh uniforms common to several materials + + if ( fog && material.fog ) { + + refreshUniformsFog( m_uniforms, fog ); + + } + + if ( material.isMeshBasicMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + + } else if ( material.isMeshLambertMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + refreshUniformsLambert( m_uniforms, material ); + + } else if ( material.isMeshPhongMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + + if ( material.isMeshToonMaterial ) { + + refreshUniformsToon( m_uniforms, material ); + + } else { + + refreshUniformsPhong( m_uniforms, material ); + + } + + } else if ( material.isMeshStandardMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + + if ( material.isMeshPhysicalMaterial ) { + + refreshUniformsPhysical( m_uniforms, material ); + + } else { + + refreshUniformsStandard( m_uniforms, material ); + + } + + } else if ( material.isMeshDepthMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + refreshUniformsDepth( m_uniforms, material ); + + } else if ( material.isMeshDistanceMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + refreshUniformsDistance( m_uniforms, material ); + + } else if ( material.isMeshNormalMaterial ) { + + refreshUniformsCommon( m_uniforms, material ); + refreshUniformsNormal( m_uniforms, material ); + + } else if ( material.isLineBasicMaterial ) { + + refreshUniformsLine( m_uniforms, material ); + + if ( material.isLineDashedMaterial ) { + + refreshUniformsDash( m_uniforms, material ); + + } + + } else if ( material.isPointsMaterial ) { + + refreshUniformsPoints( m_uniforms, material ); + + } else if ( material.isShadowMaterial ) { + + m_uniforms.color.value = material.color; + m_uniforms.opacity.value = material.opacity; + + } + + // RectAreaLight Texture + // TODO (mrdoob): Find a nicer implementation + + if ( m_uniforms.ltcMat !== undefined ) m_uniforms.ltcMat.value = UniformsLib.LTC_MAT_TEXTURE; + if ( m_uniforms.ltcMag !== undefined ) m_uniforms.ltcMag.value = UniformsLib.LTC_MAG_TEXTURE; + + WebGLUniforms.upload( + _gl, materialProperties.uniformsList, m_uniforms, _this ); + + } + + + // common matrices + + p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix ); + p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix ); + p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld ); + + return program; + + } + + // Uniforms (refresh uniforms objects) + + function refreshUniformsCommon( uniforms, material ) { + + uniforms.opacity.value = material.opacity; + + if ( material.color ) { + + uniforms.diffuse.value = material.color; + + } + + if ( material.emissive ) { + + uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity ); + + } + + if ( material.map ) { + + uniforms.map.value = material.map; + + } + + if ( material.alphaMap ) { + + uniforms.alphaMap.value = material.alphaMap; + + } + + if ( material.specularMap ) { + + uniforms.specularMap.value = material.specularMap; + + } + + if ( material.envMap ) { + + uniforms.envMap.value = material.envMap; + + // don't flip CubeTexture envMaps, flip everything else: + // WebGLRenderTargetCube will be flipped for backwards compatibility + // WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture + // this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future + uniforms.flipEnvMap.value = ( ! ( material.envMap && material.envMap.isCubeTexture ) ) ? 1 : - 1; + + uniforms.reflectivity.value = material.reflectivity; + uniforms.refractionRatio.value = material.refractionRatio; + + } + + if ( material.lightMap ) { + + uniforms.lightMap.value = material.lightMap; + uniforms.lightMapIntensity.value = material.lightMapIntensity; + + } + + if ( material.aoMap ) { + + uniforms.aoMap.value = material.aoMap; + uniforms.aoMapIntensity.value = material.aoMapIntensity; + + } + + // uv repeat and offset setting priorities + // 1. color map + // 2. specular map + // 3. normal map + // 4. bump map + // 5. alpha map + // 6. emissive map + + var uvScaleMap; + + if ( material.map ) { + + uvScaleMap = material.map; + + } else if ( material.specularMap ) { + + uvScaleMap = material.specularMap; + + } else if ( material.displacementMap ) { + + uvScaleMap = material.displacementMap; + + } else if ( material.normalMap ) { + + uvScaleMap = material.normalMap; + + } else if ( material.bumpMap ) { + + uvScaleMap = material.bumpMap; + + } else if ( material.roughnessMap ) { + + uvScaleMap = material.roughnessMap; + + } else if ( material.metalnessMap ) { + + uvScaleMap = material.metalnessMap; + + } else if ( material.alphaMap ) { + + uvScaleMap = material.alphaMap; + + } else if ( material.emissiveMap ) { + + uvScaleMap = material.emissiveMap; + + } + + if ( uvScaleMap !== undefined ) { + + // backwards compatibility + if ( uvScaleMap.isWebGLRenderTarget ) { + + uvScaleMap = uvScaleMap.texture; + + } + + if ( uvScaleMap.matrixAutoUpdate === true ) { + + var offset = uvScaleMap.offset; + var repeat = uvScaleMap.repeat; + var rotation = uvScaleMap.rotation; + var center = uvScaleMap.center; + + uvScaleMap.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y ); + + } + + uniforms.uvTransform.value.copy( uvScaleMap.matrix ); + + } + + } + + function refreshUniformsLine( uniforms, material ) { + + uniforms.diffuse.value = material.color; + uniforms.opacity.value = material.opacity; + + } + + function refreshUniformsDash( uniforms, material ) { + + uniforms.dashSize.value = material.dashSize; + uniforms.totalSize.value = material.dashSize + material.gapSize; + uniforms.scale.value = material.scale; + + } + + function refreshUniformsPoints( uniforms, material ) { + + uniforms.diffuse.value = material.color; + uniforms.opacity.value = material.opacity; + uniforms.size.value = material.size * _pixelRatio; + uniforms.scale.value = _height * 0.5; + + uniforms.map.value = material.map; + + if ( material.map !== null ) { + + if ( material.map.matrixAutoUpdate === true ) { + + var offset = material.map.offset; + var repeat = material.map.repeat; + var rotation = material.map.rotation; + var center = material.map.center; + + material.map.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y ); + + } + + uniforms.uvTransform.value.copy( material.map.matrix ); + + } + + } + + function refreshUniformsFog( uniforms, fog ) { + + uniforms.fogColor.value = fog.color; + + if ( fog.isFog ) { + + uniforms.fogNear.value = fog.near; + uniforms.fogFar.value = fog.far; + + } else if ( fog.isFogExp2 ) { + + uniforms.fogDensity.value = fog.density; + + } + + } + + function refreshUniformsLambert( uniforms, material ) { + + if ( material.emissiveMap ) { + + uniforms.emissiveMap.value = material.emissiveMap; + + } + + } + + function refreshUniformsPhong( uniforms, material ) { + + uniforms.specular.value = material.specular; + uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 ) + + if ( material.emissiveMap ) { + + uniforms.emissiveMap.value = material.emissiveMap; + + } + + if ( material.bumpMap ) { + + uniforms.bumpMap.value = material.bumpMap; + uniforms.bumpScale.value = material.bumpScale; + + } + + if ( material.normalMap ) { + + uniforms.normalMap.value = material.normalMap; + uniforms.normalScale.value.copy( material.normalScale ); + + } + + if ( material.displacementMap ) { + + uniforms.displacementMap.value = material.displacementMap; + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + + } + + } + + function refreshUniformsToon( uniforms, material ) { + + refreshUniformsPhong( uniforms, material ); + + if ( material.gradientMap ) { + + uniforms.gradientMap.value = material.gradientMap; + + } + + } + + function refreshUniformsStandard( uniforms, material ) { + + uniforms.roughness.value = material.roughness; + uniforms.metalness.value = material.metalness; + + if ( material.roughnessMap ) { + + uniforms.roughnessMap.value = material.roughnessMap; + + } + + if ( material.metalnessMap ) { + + uniforms.metalnessMap.value = material.metalnessMap; + + } + + if ( material.emissiveMap ) { + + uniforms.emissiveMap.value = material.emissiveMap; + + } + + if ( material.bumpMap ) { + + uniforms.bumpMap.value = material.bumpMap; + uniforms.bumpScale.value = material.bumpScale; + + } + + if ( material.normalMap ) { + + uniforms.normalMap.value = material.normalMap; + uniforms.normalScale.value.copy( material.normalScale ); + + } + + if ( material.displacementMap ) { + + uniforms.displacementMap.value = material.displacementMap; + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + + } + + if ( material.envMap ) { + + //uniforms.envMap.value = material.envMap; // part of uniforms common + uniforms.envMapIntensity.value = material.envMapIntensity; + + } + + } + + function refreshUniformsPhysical( uniforms, material ) { + + uniforms.clearCoat.value = material.clearCoat; + uniforms.clearCoatRoughness.value = material.clearCoatRoughness; + + refreshUniformsStandard( uniforms, material ); + + } + + function refreshUniformsDepth( uniforms, material ) { + + if ( material.displacementMap ) { + + uniforms.displacementMap.value = material.displacementMap; + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + + } + + } + + function refreshUniformsDistance( uniforms, material ) { + + if ( material.displacementMap ) { + + uniforms.displacementMap.value = material.displacementMap; + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + + } + + uniforms.referencePosition.value.copy( material.referencePosition ); + uniforms.nearDistance.value = material.nearDistance; + uniforms.farDistance.value = material.farDistance; + + } + + function refreshUniformsNormal( uniforms, material ) { + + if ( material.bumpMap ) { + + uniforms.bumpMap.value = material.bumpMap; + uniforms.bumpScale.value = material.bumpScale; + + } + + if ( material.normalMap ) { + + uniforms.normalMap.value = material.normalMap; + uniforms.normalScale.value.copy( material.normalScale ); + + } + + if ( material.displacementMap ) { + + uniforms.displacementMap.value = material.displacementMap; + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + + } + + } + + // If uniforms are marked as clean, they don't need to be loaded to the GPU. + + function markUniformsLightsNeedsUpdate( uniforms, value ) { + + uniforms.ambientLightColor.needsUpdate = value; + + uniforms.directionalLights.needsUpdate = value; + uniforms.pointLights.needsUpdate = value; + uniforms.spotLights.needsUpdate = value; + uniforms.rectAreaLights.needsUpdate = value; + uniforms.hemisphereLights.needsUpdate = value; + + } + + // GL state setting + + this.setFaceCulling = function ( cullFace, frontFaceDirection ) { + + state.setCullFace( cullFace ); + state.setFlipSided( frontFaceDirection === FrontFaceDirectionCW ); + + }; + + // Textures + + function allocTextureUnit() { + + var textureUnit = _usedTextureUnits; + + if ( textureUnit >= capabilities.maxTextures ) { + + console.warn( 'THREE.WebGLRenderer: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures ); + + } + + _usedTextureUnits += 1; + + return textureUnit; + + } + + this.allocTextureUnit = allocTextureUnit; + + // this.setTexture2D = setTexture2D; + this.setTexture2D = ( function () { + + var warned = false; + + // backwards compatibility: peel texture.texture + return function setTexture2D( texture, slot ) { + + if ( texture && texture.isWebGLRenderTarget ) { + + if ( ! warned ) { + + console.warn( "THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead." ); + warned = true; + + } + + texture = texture.texture; + + } + + textures.setTexture2D( texture, slot ); + + }; + + }() ); + + this.setTexture = ( function () { + + var warned = false; + + return function setTexture( texture, slot ) { + + if ( ! warned ) { + + console.warn( "THREE.WebGLRenderer: .setTexture is deprecated, use setTexture2D instead." ); + warned = true; + + } + + textures.setTexture2D( texture, slot ); + + }; + + }() ); + + this.setTextureCube = ( function () { + + var warned = false; + + return function setTextureCube( texture, slot ) { + + // backwards compatibility: peel texture.texture + if ( texture && texture.isWebGLRenderTargetCube ) { + + if ( ! warned ) { + + console.warn( "THREE.WebGLRenderer.setTextureCube: don't use cube render targets as textures. Use their .texture property instead." ); + warned = true; + + } + + texture = texture.texture; + + } + + // currently relying on the fact that WebGLRenderTargetCube.texture is a Texture and NOT a CubeTexture + // TODO: unify these code paths + if ( ( texture && texture.isCubeTexture ) || + ( Array.isArray( texture.image ) && texture.image.length === 6 ) ) { + + // CompressedTexture can have Array in image :/ + + // this function alone should take care of cube textures + textures.setTextureCube( texture, slot ); + + } else { + + // assumed: texture property of THREE.WebGLRenderTargetCube + + textures.setTextureCubeDynamic( texture, slot ); + + } + + }; + + }() ); + + this.getRenderTarget = function () { + + return _currentRenderTarget; + + }; + + this.setRenderTarget = function ( renderTarget ) { + + _currentRenderTarget = renderTarget; + + if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) { + + textures.setupRenderTarget( renderTarget ); + + } + + var framebuffer = null; + var isCube = false; + + if ( renderTarget ) { + + var __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer; + + if ( renderTarget.isWebGLRenderTargetCube ) { + + framebuffer = __webglFramebuffer[ renderTarget.activeCubeFace ]; + isCube = true; + + } else { + + framebuffer = __webglFramebuffer; + + } + + _currentViewport.copy( renderTarget.viewport ); + _currentScissor.copy( renderTarget.scissor ); + _currentScissorTest = renderTarget.scissorTest; + + } else { + + _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ); + _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ); + _currentScissorTest = _scissorTest; + + } + + if ( _currentFramebuffer !== framebuffer ) { + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); + _currentFramebuffer = framebuffer; + + } + + state.viewport( _currentViewport ); + state.scissor( _currentScissor ); + state.setScissorTest( _currentScissorTest ); + + if ( isCube ) { + + var textureProperties = properties.get( renderTarget.texture ); + _gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, renderTarget.activeMipMapLevel ); + + } + + }; + + this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) { + + if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) { + + console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' ); + return; + + } + + var framebuffer = properties.get( renderTarget ).__webglFramebuffer; + + if ( framebuffer ) { + + var restore = false; + + if ( framebuffer !== _currentFramebuffer ) { + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); + + restore = true; + + } + + try { + + var texture = renderTarget.texture; + var textureFormat = texture.format; + var textureType = texture.type; + + if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) { + + console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' ); + return; + + } + + if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // IE11, Edge and Chrome Mac < 52 (#9513) + ! ( textureType === FloatType && ( extensions.get( 'OES_texture_float' ) || extensions.get( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox + ! ( textureType === HalfFloatType && extensions.get( 'EXT_color_buffer_half_float' ) ) ) { + + console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' ); + return; + + } + + if ( _gl.checkFramebufferStatus( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) { + + // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604) + + if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) { + + _gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer ); + + } + + } else { + + console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' ); + + } + + } finally { + + if ( restore ) { + + _gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer ); + + } + + } + + } + + }; + + } + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function FogExp2( color, density ) { + + this.name = ''; + + this.color = new Color( color ); + this.density = ( density !== undefined ) ? density : 0.00025; + + } + + FogExp2.prototype.isFogExp2 = true; + + FogExp2.prototype.clone = function () { + + return new FogExp2( this.color.getHex(), this.density ); + + }; + + FogExp2.prototype.toJSON = function ( /* meta */ ) { + + return { + type: 'FogExp2', + color: this.color.getHex(), + density: this.density + }; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function Fog( color, near, far ) { + + this.name = ''; + + this.color = new Color( color ); + + this.near = ( near !== undefined ) ? near : 1; + this.far = ( far !== undefined ) ? far : 1000; + + } + + Fog.prototype.isFog = true; + + Fog.prototype.clone = function () { + + return new Fog( this.color.getHex(), this.near, this.far ); + + }; + + Fog.prototype.toJSON = function ( /* meta */ ) { + + return { + type: 'Fog', + color: this.color.getHex(), + near: this.near, + far: this.far + }; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Scene() { + + Object3D.call( this ); + + this.type = 'Scene'; + + this.background = null; + this.fog = null; + this.overrideMaterial = null; + + this.autoUpdate = true; // checked by the renderer + + } + + Scene.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Scene, + + copy: function ( source, recursive ) { + + Object3D.prototype.copy.call( this, source, recursive ); + + if ( source.background !== null ) this.background = source.background.clone(); + if ( source.fog !== null ) this.fog = source.fog.clone(); + if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone(); + + this.autoUpdate = source.autoUpdate; + this.matrixAutoUpdate = source.matrixAutoUpdate; + + return this; + + }, + + toJSON: function ( meta ) { + + var data = Object3D.prototype.toJSON.call( this, meta ); + + if ( this.background !== null ) data.object.background = this.background.toJSON( meta ); + if ( this.fog !== null ) data.object.fog = this.fog.toJSON(); + + return data; + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + */ + + function LensFlare( texture, size, distance, blending, color ) { + + Object3D.call( this ); + + this.lensFlares = []; + + this.positionScreen = new Vector3(); + this.customUpdateCallback = undefined; + + if ( texture !== undefined ) { + + this.add( texture, size, distance, blending, color ); + + } + + } + + LensFlare.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: LensFlare, + + isLensFlare: true, + + copy: function ( source ) { + + Object3D.prototype.copy.call( this, source ); + + this.positionScreen.copy( source.positionScreen ); + this.customUpdateCallback = source.customUpdateCallback; + + for ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) { + + this.lensFlares.push( source.lensFlares[ i ] ); + + } + + return this; + + }, + + add: function ( texture, size, distance, blending, color, opacity ) { + + if ( size === undefined ) size = - 1; + if ( distance === undefined ) distance = 0; + if ( opacity === undefined ) opacity = 1; + if ( color === undefined ) color = new Color( 0xffffff ); + if ( blending === undefined ) blending = NormalBlending; + + distance = Math.min( distance, Math.max( 0, distance ) ); + + this.lensFlares.push( { + texture: texture, // THREE.Texture + size: size, // size in pixels (-1 = use texture.width) + distance: distance, // distance (0-1) from light source (0=at light source) + x: 0, y: 0, z: 0, // screen position (-1 => 1) z = 0 is in front z = 1 is back + scale: 1, // scale + rotation: 0, // rotation + opacity: opacity, // opacity + color: color, // color + blending: blending // blending + } ); + + }, + + /* + * Update lens flares update positions on all flares based on the screen position + * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way. + */ + + updateLensFlares: function () { + + var f, fl = this.lensFlares.length; + var flare; + var vecX = - this.positionScreen.x * 2; + var vecY = - this.positionScreen.y * 2; + + for ( f = 0; f < fl; f ++ ) { + + flare = this.lensFlares[ f ]; + + flare.x = this.positionScreen.x + vecX * flare.distance; + flare.y = this.positionScreen.y + vecY * flare.distance; + + flare.wantedRotation = flare.x * Math.PI * 0.25; + flare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25; + + } + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * map: new THREE.Texture( ), + * + * uvOffset: new THREE.Vector2(), + * uvScale: new THREE.Vector2() + * } + */ + + function SpriteMaterial( parameters ) { + + Material.call( this ); + + this.type = 'SpriteMaterial'; + + this.color = new Color( 0xffffff ); + this.map = null; + + this.rotation = 0; + + this.fog = false; + this.lights = false; + + this.setValues( parameters ); + + } + + SpriteMaterial.prototype = Object.create( Material.prototype ); + SpriteMaterial.prototype.constructor = SpriteMaterial; + SpriteMaterial.prototype.isSpriteMaterial = true; + + SpriteMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + this.map = source.map; + + this.rotation = source.rotation; + + return this; + + }; + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + */ + + function Sprite( material ) { + + Object3D.call( this ); + + this.type = 'Sprite'; + + this.material = ( material !== undefined ) ? material : new SpriteMaterial(); + + } + + Sprite.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Sprite, + + isSprite: true, + + raycast: ( function () { + + var intersectPoint = new Vector3(); + var worldPosition = new Vector3(); + var worldScale = new Vector3(); + + return function raycast( raycaster, intersects ) { + + worldPosition.setFromMatrixPosition( this.matrixWorld ); + raycaster.ray.closestPointToPoint( worldPosition, intersectPoint ); + + worldScale.setFromMatrixScale( this.matrixWorld ); + var guessSizeSq = worldScale.x * worldScale.y / 4; + + if ( worldPosition.distanceToSquared( intersectPoint ) > guessSizeSq ) return; + + var distance = raycaster.ray.origin.distanceTo( intersectPoint ); + + if ( distance < raycaster.near || distance > raycaster.far ) return; + + intersects.push( { + + distance: distance, + point: intersectPoint.clone(), + face: null, + object: this + + } ); + + }; + + }() ), + + clone: function () { + + return new this.constructor( this.material ).copy( this ); + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + */ + + function LOD() { + + Object3D.call( this ); + + this.type = 'LOD'; + + Object.defineProperties( this, { + levels: { + enumerable: true, + value: [] + } + } ); + + } + + LOD.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: LOD, + + copy: function ( source ) { + + Object3D.prototype.copy.call( this, source, false ); + + var levels = source.levels; + + for ( var i = 0, l = levels.length; i < l; i ++ ) { + + var level = levels[ i ]; + + this.addLevel( level.object.clone(), level.distance ); + + } + + return this; + + }, + + addLevel: function ( object, distance ) { + + if ( distance === undefined ) distance = 0; + + distance = Math.abs( distance ); + + var levels = this.levels; + + for ( var l = 0; l < levels.length; l ++ ) { + + if ( distance < levels[ l ].distance ) { + + break; + + } + + } + + levels.splice( l, 0, { distance: distance, object: object } ); + + this.add( object ); + + }, + + getObjectForDistance: function ( distance ) { + + var levels = this.levels; + + for ( var i = 1, l = levels.length; i < l; i ++ ) { + + if ( distance < levels[ i ].distance ) { + + break; + + } + + } + + return levels[ i - 1 ].object; + + }, + + raycast: ( function () { + + var matrixPosition = new Vector3(); + + return function raycast( raycaster, intersects ) { + + matrixPosition.setFromMatrixPosition( this.matrixWorld ); + + var distance = raycaster.ray.origin.distanceTo( matrixPosition ); + + this.getObjectForDistance( distance ).raycast( raycaster, intersects ); + + }; + + }() ), + + update: function () { + + var v1 = new Vector3(); + var v2 = new Vector3(); + + return function update( camera ) { + + var levels = this.levels; + + if ( levels.length > 1 ) { + + v1.setFromMatrixPosition( camera.matrixWorld ); + v2.setFromMatrixPosition( this.matrixWorld ); + + var distance = v1.distanceTo( v2 ); + + levels[ 0 ].object.visible = true; + + for ( var i = 1, l = levels.length; i < l; i ++ ) { + + if ( distance >= levels[ i ].distance ) { + + levels[ i - 1 ].object.visible = false; + levels[ i ].object.visible = true; + + } else { + + break; + + } + + } + + for ( ; i < l; i ++ ) { + + levels[ i ].object.visible = false; + + } + + } + + }; + + }(), + + toJSON: function ( meta ) { + + var data = Object3D.prototype.toJSON.call( this, meta ); + + data.object.levels = []; + + var levels = this.levels; + + for ( var i = 0, l = levels.length; i < l; i ++ ) { + + var level = levels[ i ]; + + data.object.levels.push( { + object: level.object.uuid, + distance: level.distance + } ); + + } + + return data; + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author michael guerrero / http://realitymeltdown.com + * @author ikerr / http://verold.com + */ + + function Skeleton( bones, boneInverses ) { + + // copy the bone array + + bones = bones || []; + + this.bones = bones.slice( 0 ); + this.boneMatrices = new Float32Array( this.bones.length * 16 ); + + // use the supplied bone inverses or calculate the inverses + + if ( boneInverses === undefined ) { + + this.calculateInverses(); + + } else { + + if ( this.bones.length === boneInverses.length ) { + + this.boneInverses = boneInverses.slice( 0 ); + + } else { + + console.warn( 'THREE.Skeleton boneInverses is the wrong length.' ); + + this.boneInverses = []; + + for ( var i = 0, il = this.bones.length; i < il; i ++ ) { + + this.boneInverses.push( new Matrix4() ); + + } + + } + + } + + } + + Object.assign( Skeleton.prototype, { + + calculateInverses: function () { + + this.boneInverses = []; + + for ( var i = 0, il = this.bones.length; i < il; i ++ ) { + + var inverse = new Matrix4(); + + if ( this.bones[ i ] ) { + + inverse.getInverse( this.bones[ i ].matrixWorld ); + + } + + this.boneInverses.push( inverse ); + + } + + }, + + pose: function () { + + var bone, i, il; + + // recover the bind-time world matrices + + for ( i = 0, il = this.bones.length; i < il; i ++ ) { + + bone = this.bones[ i ]; + + if ( bone ) { + + bone.matrixWorld.getInverse( this.boneInverses[ i ] ); + + } + + } + + // compute the local matrices, positions, rotations and scales + + for ( i = 0, il = this.bones.length; i < il; i ++ ) { + + bone = this.bones[ i ]; + + if ( bone ) { + + if ( bone.parent && bone.parent.isBone ) { + + bone.matrix.getInverse( bone.parent.matrixWorld ); + bone.matrix.multiply( bone.matrixWorld ); + + } else { + + bone.matrix.copy( bone.matrixWorld ); + + } + + bone.matrix.decompose( bone.position, bone.quaternion, bone.scale ); + + } + + } + + }, + + update: ( function () { + + var offsetMatrix = new Matrix4(); + var identityMatrix = new Matrix4(); + + return function update() { + + var bones = this.bones; + var boneInverses = this.boneInverses; + var boneMatrices = this.boneMatrices; + var boneTexture = this.boneTexture; + + // flatten bone matrices to array + + for ( var i = 0, il = bones.length; i < il; i ++ ) { + + // compute the offset between the current and the original transform + + var matrix = bones[ i ] ? bones[ i ].matrixWorld : identityMatrix; + + offsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] ); + offsetMatrix.toArray( boneMatrices, i * 16 ); + + } + + if ( boneTexture !== undefined ) { + + boneTexture.needsUpdate = true; + + } + + }; + + } )(), + + clone: function () { + + return new Skeleton( this.bones, this.boneInverses ); + + } + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author ikerr / http://verold.com + */ + + function Bone() { + + Object3D.call( this ); + + this.type = 'Bone'; + + } + + Bone.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Bone, + + isBone: true + + } ); + + /** + * @author mikael emtinger / http://gomo.se/ + * @author alteredq / http://alteredqualia.com/ + * @author ikerr / http://verold.com + */ + + function SkinnedMesh( geometry, material ) { + + Mesh.call( this, geometry, material ); + + this.type = 'SkinnedMesh'; + + this.bindMode = 'attached'; + this.bindMatrix = new Matrix4(); + this.bindMatrixInverse = new Matrix4(); + + var bones = this.initBones(); + var skeleton = new Skeleton( bones ); + + this.bind( skeleton, this.matrixWorld ); + + this.normalizeSkinWeights(); + + } + + SkinnedMesh.prototype = Object.assign( Object.create( Mesh.prototype ), { + + constructor: SkinnedMesh, + + isSkinnedMesh: true, + + initBones: function () { + + var bones = [], bone, gbone; + var i, il; + + if ( this.geometry && this.geometry.bones !== undefined ) { + + // first, create array of 'Bone' objects from geometry data + + for ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) { + + gbone = this.geometry.bones[ i ]; + + // create new 'Bone' object + + bone = new Bone(); + bones.push( bone ); + + // apply values + + bone.name = gbone.name; + bone.position.fromArray( gbone.pos ); + bone.quaternion.fromArray( gbone.rotq ); + if ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl ); + + } + + // second, create bone hierarchy + + for ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) { + + gbone = this.geometry.bones[ i ]; + + if ( ( gbone.parent !== - 1 ) && ( gbone.parent !== null ) && ( bones[ gbone.parent ] !== undefined ) ) { + + // subsequent bones in the hierarchy + + bones[ gbone.parent ].add( bones[ i ] ); + + } else { + + // topmost bone, immediate child of the skinned mesh + + this.add( bones[ i ] ); + + } + + } + + } + + // now the bones are part of the scene graph and children of the skinned mesh. + // let's update the corresponding matrices + + this.updateMatrixWorld( true ); + + return bones; + + }, + + bind: function ( skeleton, bindMatrix ) { + + this.skeleton = skeleton; + + if ( bindMatrix === undefined ) { + + this.updateMatrixWorld( true ); + + this.skeleton.calculateInverses(); + + bindMatrix = this.matrixWorld; + + } + + this.bindMatrix.copy( bindMatrix ); + this.bindMatrixInverse.getInverse( bindMatrix ); + + }, + + pose: function () { + + this.skeleton.pose(); + + }, + + normalizeSkinWeights: function () { + + var scale, i; + + if ( this.geometry && this.geometry.isGeometry ) { + + for ( i = 0; i < this.geometry.skinWeights.length; i ++ ) { + + var sw = this.geometry.skinWeights[ i ]; + + scale = 1.0 / sw.manhattanLength(); + + if ( scale !== Infinity ) { + + sw.multiplyScalar( scale ); + + } else { + + sw.set( 1, 0, 0, 0 ); // do something reasonable + + } + + } + + } else if ( this.geometry && this.geometry.isBufferGeometry ) { + + var vec = new Vector4(); + + var skinWeight = this.geometry.attributes.skinWeight; + + for ( i = 0; i < skinWeight.count; i ++ ) { + + vec.x = skinWeight.getX( i ); + vec.y = skinWeight.getY( i ); + vec.z = skinWeight.getZ( i ); + vec.w = skinWeight.getW( i ); + + scale = 1.0 / vec.manhattanLength(); + + if ( scale !== Infinity ) { + + vec.multiplyScalar( scale ); + + } else { + + vec.set( 1, 0, 0, 0 ); // do something reasonable + + } + + skinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w ); + + } + + } + + }, + + updateMatrixWorld: function ( force ) { + + Mesh.prototype.updateMatrixWorld.call( this, force ); + + if ( this.bindMode === 'attached' ) { + + this.bindMatrixInverse.getInverse( this.matrixWorld ); + + } else if ( this.bindMode === 'detached' ) { + + this.bindMatrixInverse.getInverse( this.bindMatrix ); + + } else { + + console.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode ); + + } + + }, + + clone: function () { + + return new this.constructor( this.geometry, this.material ).copy( this ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * + * linewidth: , + * linecap: "round", + * linejoin: "round" + * } + */ + + function LineBasicMaterial( parameters ) { + + Material.call( this ); + + this.type = 'LineBasicMaterial'; + + this.color = new Color( 0xffffff ); + + this.linewidth = 1; + this.linecap = 'round'; + this.linejoin = 'round'; + + this.lights = false; + + this.setValues( parameters ); + + } + + LineBasicMaterial.prototype = Object.create( Material.prototype ); + LineBasicMaterial.prototype.constructor = LineBasicMaterial; + + LineBasicMaterial.prototype.isLineBasicMaterial = true; + + LineBasicMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + + this.linewidth = source.linewidth; + this.linecap = source.linecap; + this.linejoin = source.linejoin; + + return this; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Line( geometry, material, mode ) { + + if ( mode === 1 ) { + + console.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' ); + return new LineSegments( geometry, material ); + + } + + Object3D.call( this ); + + this.type = 'Line'; + + this.geometry = geometry !== undefined ? geometry : new BufferGeometry(); + this.material = material !== undefined ? material : new LineBasicMaterial( { color: Math.random() * 0xffffff } ); + + } + + Line.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Line, + + isLine: true, + + raycast: ( function () { + + var inverseMatrix = new Matrix4(); + var ray = new Ray(); + var sphere = new Sphere(); + + return function raycast( raycaster, intersects ) { + + var precision = raycaster.linePrecision; + var precisionSq = precision * precision; + + var geometry = this.geometry; + var matrixWorld = this.matrixWorld; + + // Checking boundingSphere distance to ray + + if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); + + sphere.copy( geometry.boundingSphere ); + sphere.applyMatrix4( matrixWorld ); + + if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; + + // + + inverseMatrix.getInverse( matrixWorld ); + ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); + + var vStart = new Vector3(); + var vEnd = new Vector3(); + var interSegment = new Vector3(); + var interRay = new Vector3(); + var step = ( this && this.isLineSegments ) ? 2 : 1; + + if ( geometry.isBufferGeometry ) { + + var index = geometry.index; + var attributes = geometry.attributes; + var positions = attributes.position.array; + + if ( index !== null ) { + + var indices = index.array; + + for ( var i = 0, l = indices.length - 1; i < l; i += step ) { + + var a = indices[ i ]; + var b = indices[ i + 1 ]; + + vStart.fromArray( positions, a * 3 ); + vEnd.fromArray( positions, b * 3 ); + + var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment ); + + if ( distSq > precisionSq ) continue; + + interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation + + var distance = raycaster.ray.origin.distanceTo( interRay ); + + if ( distance < raycaster.near || distance > raycaster.far ) continue; + + intersects.push( { + + distance: distance, + // What do we want? intersection point on the ray or on the segment?? + // point: raycaster.ray.at( distance ), + point: interSegment.clone().applyMatrix4( this.matrixWorld ), + index: i, + face: null, + faceIndex: null, + object: this + + } ); + + } + + } else { + + for ( var i = 0, l = positions.length / 3 - 1; i < l; i += step ) { + + vStart.fromArray( positions, 3 * i ); + vEnd.fromArray( positions, 3 * i + 3 ); + + var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment ); + + if ( distSq > precisionSq ) continue; + + interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation + + var distance = raycaster.ray.origin.distanceTo( interRay ); + + if ( distance < raycaster.near || distance > raycaster.far ) continue; + + intersects.push( { + + distance: distance, + // What do we want? intersection point on the ray or on the segment?? + // point: raycaster.ray.at( distance ), + point: interSegment.clone().applyMatrix4( this.matrixWorld ), + index: i, + face: null, + faceIndex: null, + object: this + + } ); + + } + + } + + } else if ( geometry.isGeometry ) { + + var vertices = geometry.vertices; + var nbVertices = vertices.length; + + for ( var i = 0; i < nbVertices - 1; i += step ) { + + var distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment ); + + if ( distSq > precisionSq ) continue; + + interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation + + var distance = raycaster.ray.origin.distanceTo( interRay ); + + if ( distance < raycaster.near || distance > raycaster.far ) continue; + + intersects.push( { + + distance: distance, + // What do we want? intersection point on the ray or on the segment?? + // point: raycaster.ray.at( distance ), + point: interSegment.clone().applyMatrix4( this.matrixWorld ), + index: i, + face: null, + faceIndex: null, + object: this + + } ); + + } + + } + + }; + + }() ), + + clone: function () { + + return new this.constructor( this.geometry, this.material ).copy( this ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function LineSegments( geometry, material ) { + + Line.call( this, geometry, material ); + + this.type = 'LineSegments'; + + } + + LineSegments.prototype = Object.assign( Object.create( Line.prototype ), { + + constructor: LineSegments, + + isLineSegments: true + + } ); + + /** + * @author mgreter / http://github.com/mgreter + */ + + function LineLoop( geometry, material ) { + + Line.call( this, geometry, material ); + + this.type = 'LineLoop'; + + } + + LineLoop.prototype = Object.assign( Object.create( Line.prototype ), { + + constructor: LineLoop, + + isLineLoop: true, + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * map: new THREE.Texture( ), + * + * size: , + * sizeAttenuation: + * } + */ + + function PointsMaterial( parameters ) { + + Material.call( this ); + + this.type = 'PointsMaterial'; + + this.color = new Color( 0xffffff ); + + this.map = null; + + this.size = 1; + this.sizeAttenuation = true; + + this.lights = false; + + this.setValues( parameters ); + + } + + PointsMaterial.prototype = Object.create( Material.prototype ); + PointsMaterial.prototype.constructor = PointsMaterial; + + PointsMaterial.prototype.isPointsMaterial = true; + + PointsMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + + this.map = source.map; + + this.size = source.size; + this.sizeAttenuation = source.sizeAttenuation; + + return this; + + }; + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function Points( geometry, material ) { + + Object3D.call( this ); + + this.type = 'Points'; + + this.geometry = geometry !== undefined ? geometry : new BufferGeometry(); + this.material = material !== undefined ? material : new PointsMaterial( { color: Math.random() * 0xffffff } ); + + } + + Points.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Points, + + isPoints: true, + + raycast: ( function () { + + var inverseMatrix = new Matrix4(); + var ray = new Ray(); + var sphere = new Sphere(); + + return function raycast( raycaster, intersects ) { + + var object = this; + var geometry = this.geometry; + var matrixWorld = this.matrixWorld; + var threshold = raycaster.params.Points.threshold; + + // Checking boundingSphere distance to ray + + if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); + + sphere.copy( geometry.boundingSphere ); + sphere.applyMatrix4( matrixWorld ); + sphere.radius += threshold; + + if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; + + // + + inverseMatrix.getInverse( matrixWorld ); + ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); + + var localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 ); + var localThresholdSq = localThreshold * localThreshold; + var position = new Vector3(); + + function testPoint( point, index ) { + + var rayPointDistanceSq = ray.distanceSqToPoint( point ); + + if ( rayPointDistanceSq < localThresholdSq ) { + + var intersectPoint = ray.closestPointToPoint( point ); + intersectPoint.applyMatrix4( matrixWorld ); + + var distance = raycaster.ray.origin.distanceTo( intersectPoint ); + + if ( distance < raycaster.near || distance > raycaster.far ) return; + + intersects.push( { + + distance: distance, + distanceToRay: Math.sqrt( rayPointDistanceSq ), + point: intersectPoint.clone(), + index: index, + face: null, + object: object + + } ); + + } + + } + + if ( geometry.isBufferGeometry ) { + + var index = geometry.index; + var attributes = geometry.attributes; + var positions = attributes.position.array; + + if ( index !== null ) { + + var indices = index.array; + + for ( var i = 0, il = indices.length; i < il; i ++ ) { + + var a = indices[ i ]; + + position.fromArray( positions, a * 3 ); + + testPoint( position, a ); + + } + + } else { + + for ( var i = 0, l = positions.length / 3; i < l; i ++ ) { + + position.fromArray( positions, i * 3 ); + + testPoint( position, i ); + + } + + } + + } else { + + var vertices = geometry.vertices; + + for ( var i = 0, l = vertices.length; i < l; i ++ ) { + + testPoint( vertices[ i ], i ); + + } + + } + + }; + + }() ), + + clone: function () { + + return new this.constructor( this.geometry, this.material ).copy( this ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Group() { + + Object3D.call( this ); + + this.type = 'Group'; + + } + + Group.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Group, + + isGroup: true + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { + + Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); + + this.generateMipmaps = false; + + // Set needsUpdate when first frame is ready + + var scope = this; + + function onLoaded() { + + video.removeEventListener( 'loadeddata', onLoaded, false ); + scope.needsUpdate = true; + + } + + video.addEventListener( 'loadeddata', onLoaded, false ); + + } + + VideoTexture.prototype = Object.assign( Object.create( Texture.prototype ), { + + constructor: VideoTexture, + + isVideoTexture: true, + + update: function () { + + var video = this.image; + + if ( video.readyState >= video.HAVE_CURRENT_DATA ) { + + this.needsUpdate = true; + + } + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function CompressedTexture( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) { + + Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ); + + this.image = { width: width, height: height }; + this.mipmaps = mipmaps; + + // no flipping for cube textures + // (also flipping doesn't work for compressed textures ) + + this.flipY = false; + + // can't generate mipmaps for compressed textures + // mips must be embedded in DDS files + + this.generateMipmaps = false; + + } + + CompressedTexture.prototype = Object.create( Texture.prototype ); + CompressedTexture.prototype.constructor = CompressedTexture; + + CompressedTexture.prototype.isCompressedTexture = true; + + /** + * @author Matt DesLauriers / @mattdesl + * @author atix / arthursilber.de + */ + + function DepthTexture( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) { + + format = format !== undefined ? format : DepthFormat; + + if ( format !== DepthFormat && format !== DepthStencilFormat ) { + + throw new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' ); + + } + + if ( type === undefined && format === DepthFormat ) type = UnsignedShortType; + if ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type; + + Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); + + this.image = { width: width, height: height }; + + this.magFilter = magFilter !== undefined ? magFilter : NearestFilter; + this.minFilter = minFilter !== undefined ? minFilter : NearestFilter; + + this.flipY = false; + this.generateMipmaps = false; + + } + + DepthTexture.prototype = Object.create( Texture.prototype ); + DepthTexture.prototype.constructor = DepthTexture; + DepthTexture.prototype.isDepthTexture = true; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + function WireframeGeometry( geometry ) { + + BufferGeometry.call( this ); + + this.type = 'WireframeGeometry'; + + // buffer + + var vertices = []; + + // helper variables + + var i, j, l, o, ol; + var edge = [ 0, 0 ], edges = {}, e, edge1, edge2; + var key, keys = [ 'a', 'b', 'c' ]; + var vertex; + + // different logic for Geometry and BufferGeometry + + if ( geometry && geometry.isGeometry ) { + + // create a data structure that contains all edges without duplicates + + var faces = geometry.faces; + + for ( i = 0, l = faces.length; i < l; i ++ ) { + + var face = faces[ i ]; + + for ( j = 0; j < 3; j ++ ) { + + edge1 = face[ keys[ j ] ]; + edge2 = face[ keys[ ( j + 1 ) % 3 ] ]; + edge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates + edge[ 1 ] = Math.max( edge1, edge2 ); + + key = edge[ 0 ] + ',' + edge[ 1 ]; + + if ( edges[ key ] === undefined ) { + + edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] }; + + } + + } + + } + + // generate vertices + + for ( key in edges ) { + + e = edges[ key ]; + + vertex = geometry.vertices[ e.index1 ]; + vertices.push( vertex.x, vertex.y, vertex.z ); + + vertex = geometry.vertices[ e.index2 ]; + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + } else if ( geometry && geometry.isBufferGeometry ) { + + var position, indices, groups; + var group, start, count; + var index1, index2; + + vertex = new Vector3(); + + if ( geometry.index !== null ) { + + // indexed BufferGeometry + + position = geometry.attributes.position; + indices = geometry.index; + groups = geometry.groups; + + if ( groups.length === 0 ) { + + groups = [ { start: 0, count: indices.count, materialIndex: 0 } ]; + + } + + // create a data structure that contains all eges without duplicates + + for ( o = 0, ol = groups.length; o < ol; ++ o ) { + + group = groups[ o ]; + + start = group.start; + count = group.count; + + for ( i = start, l = ( start + count ); i < l; i += 3 ) { + + for ( j = 0; j < 3; j ++ ) { + + edge1 = indices.getX( i + j ); + edge2 = indices.getX( i + ( j + 1 ) % 3 ); + edge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates + edge[ 1 ] = Math.max( edge1, edge2 ); + + key = edge[ 0 ] + ',' + edge[ 1 ]; + + if ( edges[ key ] === undefined ) { + + edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] }; + + } + + } + + } + + } + + // generate vertices + + for ( key in edges ) { + + e = edges[ key ]; + + vertex.fromBufferAttribute( position, e.index1 ); + vertices.push( vertex.x, vertex.y, vertex.z ); + + vertex.fromBufferAttribute( position, e.index2 ); + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + } else { + + // non-indexed BufferGeometry + + position = geometry.attributes.position; + + for ( i = 0, l = ( position.count / 3 ); i < l; i ++ ) { + + for ( j = 0; j < 3; j ++ ) { + + // three edges per triangle, an edge is represented as (index1, index2) + // e.g. the first triangle has the following edges: (0,1),(1,2),(2,0) + + index1 = 3 * i + j; + vertex.fromBufferAttribute( position, index1 ); + vertices.push( vertex.x, vertex.y, vertex.z ); + + index2 = 3 * i + ( ( j + 1 ) % 3 ); + vertex.fromBufferAttribute( position, index2 ); + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + } + + } + + } + + // build geometry + + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + + } + + WireframeGeometry.prototype = Object.create( BufferGeometry.prototype ); + WireframeGeometry.prototype.constructor = WireframeGeometry; + + /** + * @author zz85 / https://github.com/zz85 + * @author Mugen87 / https://github.com/Mugen87 + * + * Parametric Surfaces Geometry + * based on the brilliant article by @prideout http://prideout.net/blog/?p=44 + */ + + // ParametricGeometry + + function ParametricGeometry( func, slices, stacks ) { + + Geometry.call( this ); + + this.type = 'ParametricGeometry'; + + this.parameters = { + func: func, + slices: slices, + stacks: stacks + }; + + this.fromBufferGeometry( new ParametricBufferGeometry( func, slices, stacks ) ); + this.mergeVertices(); + + } + + ParametricGeometry.prototype = Object.create( Geometry.prototype ); + ParametricGeometry.prototype.constructor = ParametricGeometry; + + // ParametricBufferGeometry + + function ParametricBufferGeometry( func, slices, stacks ) { + + BufferGeometry.call( this ); + + this.type = 'ParametricBufferGeometry'; + + this.parameters = { + func: func, + slices: slices, + stacks: stacks + }; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + var EPS = 0.00001; + + var normal = new Vector3(); + + var p0 = new Vector3(), p1 = new Vector3(); + var pu = new Vector3(), pv = new Vector3(); + + var i, j; + + // generate vertices, normals and uvs + + var sliceCount = slices + 1; + + for ( i = 0; i <= stacks; i ++ ) { + + var v = i / stacks; + + for ( j = 0; j <= slices; j ++ ) { + + var u = j / slices; + + // vertex + + p0 = func( u, v, p0 ); + vertices.push( p0.x, p0.y, p0.z ); + + // normal + + // approximate tangent vectors via finite differences + + if ( u - EPS >= 0 ) { + + p1 = func( u - EPS, v, p1 ); + pu.subVectors( p0, p1 ); + + } else { + + p1 = func( u + EPS, v, p1 ); + pu.subVectors( p1, p0 ); + + } + + if ( v - EPS >= 0 ) { + + p1 = func( u, v - EPS, p1 ); + pv.subVectors( p0, p1 ); + + } else { + + p1 = func( u, v + EPS, p1 ); + pv.subVectors( p1, p0 ); + + } + + // cross product of tangent vectors returns surface normal + + normal.crossVectors( pu, pv ).normalize(); + normals.push( normal.x, normal.y, normal.z ); + + // uv + + uvs.push( u, v ); + + } + + } + + // generate indices + + for ( i = 0; i < stacks; i ++ ) { + + for ( j = 0; j < slices; j ++ ) { + + var a = i * sliceCount + j; + var b = i * sliceCount + j + 1; + var c = ( i + 1 ) * sliceCount + j + 1; + var d = ( i + 1 ) * sliceCount + j; + + // faces one and two + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + ParametricBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + ParametricBufferGeometry.prototype.constructor = ParametricBufferGeometry; + + /** + * @author clockworkgeek / https://github.com/clockworkgeek + * @author timothypratley / https://github.com/timothypratley + * @author WestLangley / http://github.com/WestLangley + * @author Mugen87 / https://github.com/Mugen87 + */ + + // PolyhedronGeometry + + function PolyhedronGeometry( vertices, indices, radius, detail ) { + + Geometry.call( this ); + + this.type = 'PolyhedronGeometry'; + + this.parameters = { + vertices: vertices, + indices: indices, + radius: radius, + detail: detail + }; + + this.fromBufferGeometry( new PolyhedronBufferGeometry( vertices, indices, radius, detail ) ); + this.mergeVertices(); + + } + + PolyhedronGeometry.prototype = Object.create( Geometry.prototype ); + PolyhedronGeometry.prototype.constructor = PolyhedronGeometry; + + // PolyhedronBufferGeometry + + function PolyhedronBufferGeometry( vertices, indices, radius, detail ) { + + BufferGeometry.call( this ); + + this.type = 'PolyhedronBufferGeometry'; + + this.parameters = { + vertices: vertices, + indices: indices, + radius: radius, + detail: detail + }; + + radius = radius || 1; + detail = detail || 0; + + // default buffer data + + var vertexBuffer = []; + var uvBuffer = []; + + // the subdivision creates the vertex buffer data + + subdivide( detail ); + + // all vertices should lie on a conceptual sphere with a given radius + + appplyRadius( radius ); + + // finally, create the uv data + + generateUVs(); + + // build non-indexed geometry + + this.addAttribute( 'position', new Float32BufferAttribute( vertexBuffer, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( vertexBuffer.slice(), 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvBuffer, 2 ) ); + + if ( detail === 0 ) { + + this.computeVertexNormals(); // flat normals + + } else { + + this.normalizeNormals(); // smooth normals + + } + + // helper functions + + function subdivide( detail ) { + + var a = new Vector3(); + var b = new Vector3(); + var c = new Vector3(); + + // iterate over all faces and apply a subdivison with the given detail value + + for ( var i = 0; i < indices.length; i += 3 ) { + + // get the vertices of the face + + getVertexByIndex( indices[ i + 0 ], a ); + getVertexByIndex( indices[ i + 1 ], b ); + getVertexByIndex( indices[ i + 2 ], c ); + + // perform subdivision + + subdivideFace( a, b, c, detail ); + + } + + } + + function subdivideFace( a, b, c, detail ) { + + var cols = Math.pow( 2, detail ); + + // we use this multidimensional array as a data structure for creating the subdivision + + var v = []; + + var i, j; + + // construct all of the vertices for this subdivision + + for ( i = 0; i <= cols; i ++ ) { + + v[ i ] = []; + + var aj = a.clone().lerp( c, i / cols ); + var bj = b.clone().lerp( c, i / cols ); + + var rows = cols - i; + + for ( j = 0; j <= rows; j ++ ) { + + if ( j === 0 && i === cols ) { + + v[ i ][ j ] = aj; + + } else { + + v[ i ][ j ] = aj.clone().lerp( bj, j / rows ); + + } + + } + + } + + // construct all of the faces + + for ( i = 0; i < cols; i ++ ) { + + for ( j = 0; j < 2 * ( cols - i ) - 1; j ++ ) { + + var k = Math.floor( j / 2 ); + + if ( j % 2 === 0 ) { + + pushVertex( v[ i ][ k + 1 ] ); + pushVertex( v[ i + 1 ][ k ] ); + pushVertex( v[ i ][ k ] ); + + } else { + + pushVertex( v[ i ][ k + 1 ] ); + pushVertex( v[ i + 1 ][ k + 1 ] ); + pushVertex( v[ i + 1 ][ k ] ); + + } + + } + + } + + } + + function appplyRadius( radius ) { + + var vertex = new Vector3(); + + // iterate over the entire buffer and apply the radius to each vertex + + for ( var i = 0; i < vertexBuffer.length; i += 3 ) { + + vertex.x = vertexBuffer[ i + 0 ]; + vertex.y = vertexBuffer[ i + 1 ]; + vertex.z = vertexBuffer[ i + 2 ]; + + vertex.normalize().multiplyScalar( radius ); + + vertexBuffer[ i + 0 ] = vertex.x; + vertexBuffer[ i + 1 ] = vertex.y; + vertexBuffer[ i + 2 ] = vertex.z; + + } + + } + + function generateUVs() { + + var vertex = new Vector3(); + + for ( var i = 0; i < vertexBuffer.length; i += 3 ) { + + vertex.x = vertexBuffer[ i + 0 ]; + vertex.y = vertexBuffer[ i + 1 ]; + vertex.z = vertexBuffer[ i + 2 ]; + + var u = azimuth( vertex ) / 2 / Math.PI + 0.5; + var v = inclination( vertex ) / Math.PI + 0.5; + uvBuffer.push( u, 1 - v ); + + } + + correctUVs(); + + correctSeam(); + + } + + function correctSeam() { + + // handle case when face straddles the seam, see #3269 + + for ( var i = 0; i < uvBuffer.length; i += 6 ) { + + // uv data of a single face + + var x0 = uvBuffer[ i + 0 ]; + var x1 = uvBuffer[ i + 2 ]; + var x2 = uvBuffer[ i + 4 ]; + + var max = Math.max( x0, x1, x2 ); + var min = Math.min( x0, x1, x2 ); + + // 0.9 is somewhat arbitrary + + if ( max > 0.9 && min < 0.1 ) { + + if ( x0 < 0.2 ) uvBuffer[ i + 0 ] += 1; + if ( x1 < 0.2 ) uvBuffer[ i + 2 ] += 1; + if ( x2 < 0.2 ) uvBuffer[ i + 4 ] += 1; + + } + + } + + } + + function pushVertex( vertex ) { + + vertexBuffer.push( vertex.x, vertex.y, vertex.z ); + + } + + function getVertexByIndex( index, vertex ) { + + var stride = index * 3; + + vertex.x = vertices[ stride + 0 ]; + vertex.y = vertices[ stride + 1 ]; + vertex.z = vertices[ stride + 2 ]; + + } + + function correctUVs() { + + var a = new Vector3(); + var b = new Vector3(); + var c = new Vector3(); + + var centroid = new Vector3(); + + var uvA = new Vector2(); + var uvB = new Vector2(); + var uvC = new Vector2(); + + for ( var i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6 ) { + + a.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] ); + b.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] ); + c.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] ); + + uvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] ); + uvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] ); + uvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] ); + + centroid.copy( a ).add( b ).add( c ).divideScalar( 3 ); + + var azi = azimuth( centroid ); + + correctUV( uvA, j + 0, a, azi ); + correctUV( uvB, j + 2, b, azi ); + correctUV( uvC, j + 4, c, azi ); + + } + + } + + function correctUV( uv, stride, vector, azimuth ) { + + if ( ( azimuth < 0 ) && ( uv.x === 1 ) ) { + + uvBuffer[ stride ] = uv.x - 1; + + } + + if ( ( vector.x === 0 ) && ( vector.z === 0 ) ) { + + uvBuffer[ stride ] = azimuth / 2 / Math.PI + 0.5; + + } + + } + + // Angle around the Y axis, counter-clockwise when looking from above. + + function azimuth( vector ) { + + return Math.atan2( vector.z, - vector.x ); + + } + + + // Angle above the XZ plane. + + function inclination( vector ) { + + return Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) ); + + } + + } + + PolyhedronBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + PolyhedronBufferGeometry.prototype.constructor = PolyhedronBufferGeometry; + + /** + * @author timothypratley / https://github.com/timothypratley + * @author Mugen87 / https://github.com/Mugen87 + */ + + // TetrahedronGeometry + + function TetrahedronGeometry( radius, detail ) { + + Geometry.call( this ); + + this.type = 'TetrahedronGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + this.fromBufferGeometry( new TetrahedronBufferGeometry( radius, detail ) ); + this.mergeVertices(); + + } + + TetrahedronGeometry.prototype = Object.create( Geometry.prototype ); + TetrahedronGeometry.prototype.constructor = TetrahedronGeometry; + + // TetrahedronBufferGeometry + + function TetrahedronBufferGeometry( radius, detail ) { + + var vertices = [ + 1, 1, 1, - 1, - 1, 1, - 1, 1, - 1, 1, - 1, - 1 + ]; + + var indices = [ + 2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1 + ]; + + PolyhedronBufferGeometry.call( this, vertices, indices, radius, detail ); + + this.type = 'TetrahedronBufferGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + } + + TetrahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype ); + TetrahedronBufferGeometry.prototype.constructor = TetrahedronBufferGeometry; + + /** + * @author timothypratley / https://github.com/timothypratley + * @author Mugen87 / https://github.com/Mugen87 + */ + + // OctahedronGeometry + + function OctahedronGeometry( radius, detail ) { + + Geometry.call( this ); + + this.type = 'OctahedronGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + this.fromBufferGeometry( new OctahedronBufferGeometry( radius, detail ) ); + this.mergeVertices(); + + } + + OctahedronGeometry.prototype = Object.create( Geometry.prototype ); + OctahedronGeometry.prototype.constructor = OctahedronGeometry; + + // OctahedronBufferGeometry + + function OctahedronBufferGeometry( radius, detail ) { + + var vertices = [ + 1, 0, 0, - 1, 0, 0, 0, 1, 0, + 0, - 1, 0, 0, 0, 1, 0, 0, - 1 + ]; + + var indices = [ + 0, 2, 4, 0, 4, 3, 0, 3, 5, + 0, 5, 2, 1, 2, 5, 1, 5, 3, + 1, 3, 4, 1, 4, 2 + ]; + + PolyhedronBufferGeometry.call( this, vertices, indices, radius, detail ); + + this.type = 'OctahedronBufferGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + } + + OctahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype ); + OctahedronBufferGeometry.prototype.constructor = OctahedronBufferGeometry; + + /** + * @author timothypratley / https://github.com/timothypratley + * @author Mugen87 / https://github.com/Mugen87 + */ + + // IcosahedronGeometry + + function IcosahedronGeometry( radius, detail ) { + + Geometry.call( this ); + + this.type = 'IcosahedronGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + this.fromBufferGeometry( new IcosahedronBufferGeometry( radius, detail ) ); + this.mergeVertices(); + + } + + IcosahedronGeometry.prototype = Object.create( Geometry.prototype ); + IcosahedronGeometry.prototype.constructor = IcosahedronGeometry; + + // IcosahedronBufferGeometry + + function IcosahedronBufferGeometry( radius, detail ) { + + var t = ( 1 + Math.sqrt( 5 ) ) / 2; + + var vertices = [ + - 1, t, 0, 1, t, 0, - 1, - t, 0, 1, - t, 0, + 0, - 1, t, 0, 1, t, 0, - 1, - t, 0, 1, - t, + t, 0, - 1, t, 0, 1, - t, 0, - 1, - t, 0, 1 + ]; + + var indices = [ + 0, 11, 5, 0, 5, 1, 0, 1, 7, 0, 7, 10, 0, 10, 11, + 1, 5, 9, 5, 11, 4, 11, 10, 2, 10, 7, 6, 7, 1, 8, + 3, 9, 4, 3, 4, 2, 3, 2, 6, 3, 6, 8, 3, 8, 9, + 4, 9, 5, 2, 4, 11, 6, 2, 10, 8, 6, 7, 9, 8, 1 + ]; + + PolyhedronBufferGeometry.call( this, vertices, indices, radius, detail ); + + this.type = 'IcosahedronBufferGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + } + + IcosahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype ); + IcosahedronBufferGeometry.prototype.constructor = IcosahedronBufferGeometry; + + /** + * @author Abe Pazos / https://hamoid.com + * @author Mugen87 / https://github.com/Mugen87 + */ + + // DodecahedronGeometry + + function DodecahedronGeometry( radius, detail ) { + + Geometry.call( this ); + + this.type = 'DodecahedronGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + this.fromBufferGeometry( new DodecahedronBufferGeometry( radius, detail ) ); + this.mergeVertices(); + + } + + DodecahedronGeometry.prototype = Object.create( Geometry.prototype ); + DodecahedronGeometry.prototype.constructor = DodecahedronGeometry; + + // DodecahedronBufferGeometry + + function DodecahedronBufferGeometry( radius, detail ) { + + var t = ( 1 + Math.sqrt( 5 ) ) / 2; + var r = 1 / t; + + var vertices = [ + + // (±1, ±1, ±1) + - 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, ±1/φ, ±φ) + 0, - r, - t, 0, - r, t, + 0, r, - t, 0, r, t, + + // (±1/φ, ±φ, 0) + - r, - t, 0, - r, t, 0, + r, - t, 0, r, t, 0, + + // (±φ, 0, ±1/φ) + - t, 0, - r, t, 0, - r, + - t, 0, r, t, 0, r + ]; + + var indices = [ + 3, 11, 7, 3, 7, 15, 3, 15, 13, + 7, 19, 17, 7, 17, 6, 7, 6, 15, + 17, 4, 8, 17, 8, 10, 17, 10, 6, + 8, 0, 16, 8, 16, 2, 8, 2, 10, + 0, 12, 1, 0, 1, 18, 0, 18, 16, + 6, 10, 2, 6, 2, 13, 6, 13, 15, + 2, 16, 18, 2, 18, 3, 2, 3, 13, + 18, 1, 9, 18, 9, 11, 18, 11, 3, + 4, 14, 12, 4, 12, 0, 4, 0, 8, + 11, 9, 5, 11, 5, 19, 11, 19, 7, + 19, 5, 14, 19, 14, 4, 19, 4, 17, + 1, 12, 14, 1, 14, 5, 1, 5, 9 + ]; + + PolyhedronBufferGeometry.call( this, vertices, indices, radius, detail ); + + this.type = 'DodecahedronBufferGeometry'; + + this.parameters = { + radius: radius, + detail: detail + }; + + } + + DodecahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype ); + DodecahedronBufferGeometry.prototype.constructor = DodecahedronBufferGeometry; + + /** + * @author oosmoxiecode / https://github.com/oosmoxiecode + * @author WestLangley / https://github.com/WestLangley + * @author zz85 / https://github.com/zz85 + * @author miningold / https://github.com/miningold + * @author jonobr1 / https://github.com/jonobr1 + * @author Mugen87 / https://github.com/Mugen87 + * + */ + + // TubeGeometry + + function TubeGeometry( path, tubularSegments, radius, radialSegments, closed, taper ) { + + Geometry.call( this ); + + this.type = 'TubeGeometry'; + + this.parameters = { + path: path, + tubularSegments: tubularSegments, + radius: radius, + radialSegments: radialSegments, + closed: closed + }; + + if ( taper !== undefined ) console.warn( 'THREE.TubeGeometry: taper has been removed.' ); + + var bufferGeometry = new TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed ); + + // expose internals + + this.tangents = bufferGeometry.tangents; + this.normals = bufferGeometry.normals; + this.binormals = bufferGeometry.binormals; + + // create geometry + + this.fromBufferGeometry( bufferGeometry ); + this.mergeVertices(); + + } + + TubeGeometry.prototype = Object.create( Geometry.prototype ); + TubeGeometry.prototype.constructor = TubeGeometry; + + // TubeBufferGeometry + + function TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed ) { + + BufferGeometry.call( this ); + + this.type = 'TubeBufferGeometry'; + + this.parameters = { + path: path, + tubularSegments: tubularSegments, + radius: radius, + radialSegments: radialSegments, + closed: closed + }; + + tubularSegments = tubularSegments || 64; + radius = radius || 1; + radialSegments = radialSegments || 8; + closed = closed || false; + + var frames = path.computeFrenetFrames( tubularSegments, closed ); + + // expose internals + + this.tangents = frames.tangents; + this.normals = frames.normals; + this.binormals = frames.binormals; + + // helper variables + + var vertex = new Vector3(); + var normal = new Vector3(); + var uv = new Vector2(); + var P = new Vector3(); + + var i, j; + + // buffer + + var vertices = []; + var normals = []; + var uvs = []; + var indices = []; + + // create buffer data + + generateBufferData(); + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + // functions + + function generateBufferData() { + + for ( i = 0; i < tubularSegments; i ++ ) { + + generateSegment( i ); + + } + + // if the geometry is not closed, generate the last row of vertices and normals + // at the regular position on the given path + // + // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ) + + generateSegment( ( closed === false ) ? tubularSegments : 0 ); + + // uvs are generated in a separate function. + // this makes it easy compute correct values for closed geometries + + generateUVs(); + + // finally create faces + + generateIndices(); + + } + + function generateSegment( i ) { + + // we use getPointAt to sample evenly distributed points from the given path + + P = path.getPointAt( i / tubularSegments, P ); + + // retrieve corresponding normal and binormal + + var N = frames.normals[ i ]; + var B = frames.binormals[ i ]; + + // generate normals and vertices for the current segment + + for ( j = 0; j <= radialSegments; j ++ ) { + + var v = j / radialSegments * Math.PI * 2; + + var sin = Math.sin( v ); + var cos = - Math.cos( v ); + + // normal + + normal.x = ( cos * N.x + sin * B.x ); + normal.y = ( cos * N.y + sin * B.y ); + normal.z = ( cos * N.z + sin * B.z ); + normal.normalize(); + + normals.push( normal.x, normal.y, normal.z ); + + // vertex + + vertex.x = P.x + radius * normal.x; + vertex.y = P.y + radius * normal.y; + vertex.z = P.z + radius * normal.z; + + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + } + + function generateIndices() { + + for ( j = 1; j <= tubularSegments; j ++ ) { + + for ( i = 1; i <= radialSegments; i ++ ) { + + var a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 ); + var b = ( radialSegments + 1 ) * j + ( i - 1 ); + var c = ( radialSegments + 1 ) * j + i; + var d = ( radialSegments + 1 ) * ( j - 1 ) + i; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + } + + function generateUVs() { + + for ( i = 0; i <= tubularSegments; i ++ ) { + + for ( j = 0; j <= radialSegments; j ++ ) { + + uv.x = i / tubularSegments; + uv.y = j / radialSegments; + + uvs.push( uv.x, uv.y ); + + } + + } + + } + + } + + TubeBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + TubeBufferGeometry.prototype.constructor = TubeBufferGeometry; + + /** + * @author oosmoxiecode + * @author Mugen87 / https://github.com/Mugen87 + * + * based on http://www.blackpawn.com/texts/pqtorus/ + */ + + // TorusKnotGeometry + + function TorusKnotGeometry( radius, tube, tubularSegments, radialSegments, p, q, heightScale ) { + + Geometry.call( this ); + + this.type = 'TorusKnotGeometry'; + + this.parameters = { + radius: radius, + tube: tube, + tubularSegments: tubularSegments, + radialSegments: radialSegments, + p: p, + q: q + }; + + if ( heightScale !== undefined ) console.warn( 'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.' ); + + this.fromBufferGeometry( new TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) ); + this.mergeVertices(); + + } + + TorusKnotGeometry.prototype = Object.create( Geometry.prototype ); + TorusKnotGeometry.prototype.constructor = TorusKnotGeometry; + + // TorusKnotBufferGeometry + + function TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) { + + BufferGeometry.call( this ); + + this.type = 'TorusKnotBufferGeometry'; + + this.parameters = { + radius: radius, + tube: tube, + tubularSegments: tubularSegments, + radialSegments: radialSegments, + p: p, + q: q + }; + + radius = radius || 1; + tube = tube || 0.4; + tubularSegments = Math.floor( tubularSegments ) || 64; + radialSegments = Math.floor( radialSegments ) || 8; + p = p || 2; + q = q || 3; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var i, j; + + var vertex = new Vector3(); + var normal = new Vector3(); + + var P1 = new Vector3(); + var P2 = new Vector3(); + + var B = new Vector3(); + var T = new Vector3(); + var N = new Vector3(); + + // generate vertices, normals and uvs + + for ( i = 0; i <= tubularSegments; ++ i ) { + + // the radian "u" is used to calculate the position on the torus curve of the current tubular segement + + var u = i / tubularSegments * p * Math.PI * 2; + + // now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead. + // these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions + + calculatePositionOnCurve( u, p, q, radius, P1 ); + calculatePositionOnCurve( u + 0.01, p, q, radius, P2 ); + + // calculate orthonormal basis + + T.subVectors( P2, P1 ); + N.addVectors( P2, P1 ); + B.crossVectors( T, N ); + N.crossVectors( B, T ); + + // normalize B, N. T can be ignored, we don't use it + + B.normalize(); + N.normalize(); + + for ( j = 0; j <= radialSegments; ++ j ) { + + // now calculate the vertices. they are nothing more than an extrusion of the torus curve. + // because we extrude a shape in the xy-plane, there is no need to calculate a z-value. + + var v = j / radialSegments * Math.PI * 2; + var cx = - tube * Math.cos( v ); + var cy = tube * Math.sin( v ); + + // now calculate the final vertex position. + // first we orient the extrusion with our basis vectos, then we add it to the current position on the curve + + vertex.x = P1.x + ( cx * N.x + cy * B.x ); + vertex.y = P1.y + ( cx * N.y + cy * B.y ); + vertex.z = P1.z + ( cx * N.z + cy * B.z ); + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal) + + normal.subVectors( vertex, P1 ).normalize(); + + normals.push( normal.x, normal.y, normal.z ); + + // uv + + uvs.push( i / tubularSegments ); + uvs.push( j / radialSegments ); + + } + + } + + // generate indices + + for ( j = 1; j <= tubularSegments; j ++ ) { + + for ( i = 1; i <= radialSegments; i ++ ) { + + // indices + + var a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 ); + var b = ( radialSegments + 1 ) * j + ( i - 1 ); + var c = ( radialSegments + 1 ) * j + i; + var d = ( radialSegments + 1 ) * ( j - 1 ) + i; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + // this function calculates the current position on the torus curve + + function calculatePositionOnCurve( u, p, q, radius, position ) { + + var cu = Math.cos( u ); + var su = Math.sin( u ); + var quOverP = q / p * u; + var cs = Math.cos( quOverP ); + + position.x = radius * ( 2 + cs ) * 0.5 * cu; + position.y = radius * ( 2 + cs ) * su * 0.5; + position.z = radius * Math.sin( quOverP ) * 0.5; + + } + + } + + TorusKnotBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + TorusKnotBufferGeometry.prototype.constructor = TorusKnotBufferGeometry; + + /** + * @author oosmoxiecode + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + // TorusGeometry + + function TorusGeometry( radius, tube, radialSegments, tubularSegments, arc ) { + + Geometry.call( this ); + + this.type = 'TorusGeometry'; + + this.parameters = { + radius: radius, + tube: tube, + radialSegments: radialSegments, + tubularSegments: tubularSegments, + arc: arc + }; + + this.fromBufferGeometry( new TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) ); + this.mergeVertices(); + + } + + TorusGeometry.prototype = Object.create( Geometry.prototype ); + TorusGeometry.prototype.constructor = TorusGeometry; + + // TorusBufferGeometry + + function TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) { + + BufferGeometry.call( this ); + + this.type = 'TorusBufferGeometry'; + + this.parameters = { + radius: radius, + tube: tube, + radialSegments: radialSegments, + tubularSegments: tubularSegments, + arc: arc + }; + + radius = radius || 1; + tube = tube || 0.4; + radialSegments = Math.floor( radialSegments ) || 8; + tubularSegments = Math.floor( tubularSegments ) || 6; + arc = arc || Math.PI * 2; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var center = new Vector3(); + var vertex = new Vector3(); + var normal = new Vector3(); + + var j, i; + + // generate vertices, normals and uvs + + for ( j = 0; j <= radialSegments; j ++ ) { + + for ( i = 0; i <= tubularSegments; i ++ ) { + + var u = i / tubularSegments * arc; + var v = j / radialSegments * Math.PI * 2; + + // vertex + + vertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u ); + vertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u ); + vertex.z = tube * Math.sin( v ); + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + center.x = radius * Math.cos( u ); + center.y = radius * Math.sin( u ); + normal.subVectors( vertex, center ).normalize(); + + normals.push( normal.x, normal.y, normal.z ); + + // uv + + uvs.push( i / tubularSegments ); + uvs.push( j / radialSegments ); + + } + + } + + // generate indices + + for ( j = 1; j <= radialSegments; j ++ ) { + + for ( i = 1; i <= tubularSegments; i ++ ) { + + // indices + + var a = ( tubularSegments + 1 ) * j + i - 1; + var b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1; + var c = ( tubularSegments + 1 ) * ( j - 1 ) + i; + var d = ( tubularSegments + 1 ) * j + i; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + TorusBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + TorusBufferGeometry.prototype.constructor = TorusBufferGeometry; + + /** + * @author Mugen87 / https://github.com/Mugen87 + * Port from https://github.com/mapbox/earcut (v2.1.2) + */ + + var Earcut = { + + triangulate: function ( data, holeIndices, dim ) { + + dim = dim || 2; + + var hasHoles = holeIndices && holeIndices.length, + outerLen = hasHoles ? holeIndices[ 0 ] * dim : data.length, + outerNode = linkedList( data, 0, outerLen, dim, true ), + triangles = []; + + if ( ! outerNode ) return triangles; + + var minX, minY, maxX, maxY, x, y, invSize; + + if ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim ); + + // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox + + if ( data.length > 80 * dim ) { + + minX = maxX = data[ 0 ]; + minY = maxY = data[ 1 ]; + + for ( var i = dim; i < outerLen; i += dim ) { + + x = data[ i ]; + y = data[ i + 1 ]; + if ( x < minX ) minX = x; + if ( y < minY ) minY = y; + if ( x > maxX ) maxX = x; + if ( y > maxY ) maxY = y; + + } + + // minX, minY and invSize are later used to transform coords into integers for z-order calculation + + invSize = Math.max( maxX - minX, maxY - minY ); + invSize = invSize !== 0 ? 1 / invSize : 0; + + } + + earcutLinked( outerNode, triangles, dim, minX, minY, invSize ); + + return triangles; + + } + + }; + + // create a circular doubly linked list from polygon points in the specified winding order + + function linkedList( data, start, end, dim, clockwise ) { + + var i, last; + + if ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) { + + for ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last ); + + } else { + + for ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last ); + + } + + if ( last && equals( last, last.next ) ) { + + removeNode( last ); + last = last.next; + + } + + return last; + + } + + // eliminate colinear or duplicate points + + function filterPoints( start, end ) { + + if ( ! start ) return start; + if ( ! end ) end = start; + + var p = start, again; + + do { + + again = false; + + if ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) { + + removeNode( p ); + p = end = p.prev; + if ( p === p.next ) break; + again = true; + + } else { + + p = p.next; + + } + + } while ( again || p !== end ); + + return end; + + } + + // main ear slicing loop which triangulates a polygon (given as a linked list) + + function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) { + + if ( ! ear ) return; + + // interlink polygon nodes in z-order + + if ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize ); + + var stop = ear, prev, next; + + // iterate through ears, slicing them one by one + + while ( ear.prev !== ear.next ) { + + prev = ear.prev; + next = ear.next; + + if ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) { + + // cut off the triangle + triangles.push( prev.i / dim ); + triangles.push( ear.i / dim ); + triangles.push( next.i / dim ); + + removeNode( ear ); + + // skipping the next vertice leads to less sliver triangles + ear = next.next; + stop = next.next; + + continue; + + } + + ear = next; + + // if we looped through the whole remaining polygon and can't find any more ears + + if ( ear === stop ) { + + // try filtering points and slicing again + + if ( ! pass ) { + + earcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 ); + + // if this didn't work, try curing all small self-intersections locally + + } else if ( pass === 1 ) { + + ear = cureLocalIntersections( ear, triangles, dim ); + earcutLinked( ear, triangles, dim, minX, minY, invSize, 2 ); + + // as a last resort, try splitting the remaining polygon into two + + } else if ( pass === 2 ) { + + splitEarcut( ear, triangles, dim, minX, minY, invSize ); + + } + + break; + + } + + } + + } + + // check whether a polygon node forms a valid ear with adjacent nodes + + function isEar( ear ) { + + var a = ear.prev, + b = ear, + c = ear.next; + + if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear + + // now make sure we don't have other points inside the potential ear + var p = ear.next.next; + + while ( p !== ear.prev ) { + + if ( pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) { + + return false; + + } + + p = p.next; + + } + + return true; + + } + + function isEarHashed( ear, minX, minY, invSize ) { + + var a = ear.prev, + b = ear, + c = ear.next; + + if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear + + // triangle bbox; min & max are calculated like this for speed + + var minTX = a.x < b.x ? ( a.x < c.x ? a.x : c.x ) : ( b.x < c.x ? b.x : c.x ), + minTY = a.y < b.y ? ( a.y < c.y ? a.y : c.y ) : ( b.y < c.y ? b.y : c.y ), + maxTX = a.x > b.x ? ( a.x > c.x ? a.x : c.x ) : ( b.x > c.x ? b.x : c.x ), + maxTY = a.y > b.y ? ( a.y > c.y ? a.y : c.y ) : ( b.y > c.y ? b.y : c.y ); + + // z-order range for the current triangle bbox; + + var minZ = zOrder( minTX, minTY, minX, minY, invSize ), + maxZ = zOrder( maxTX, maxTY, minX, minY, invSize ); + + // first look for points inside the triangle in increasing z-order + + var p = ear.nextZ; + + while ( p && p.z <= maxZ ) { + + if ( p !== ear.prev && p !== ear.next && + pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) && + area( p.prev, p, p.next ) >= 0 ) return false; + p = p.nextZ; + + } + + // then look for points in decreasing z-order + + p = ear.prevZ; + + while ( p && p.z >= minZ ) { + + if ( p !== ear.prev && p !== ear.next && + pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) && + area( p.prev, p, p.next ) >= 0 ) return false; + + p = p.prevZ; + + } + + return true; + + } + + // go through all polygon nodes and cure small local self-intersections + + function cureLocalIntersections( start, triangles, dim ) { + + var p = start; + + do { + + var a = p.prev, b = p.next.next; + + if ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) { + + triangles.push( a.i / dim ); + triangles.push( p.i / dim ); + triangles.push( b.i / dim ); + + // remove two nodes involved + + removeNode( p ); + removeNode( p.next ); + + p = start = b; + + } + + p = p.next; + + } while ( p !== start ); + + return p; + + } + + // try splitting polygon into two and triangulate them independently + + function splitEarcut( start, triangles, dim, minX, minY, invSize ) { + + // look for a valid diagonal that divides the polygon into two + + var a = start; + + do { + + var b = a.next.next; + + while ( b !== a.prev ) { + + if ( a.i !== b.i && isValidDiagonal( a, b ) ) { + + // split the polygon in two by the diagonal + + var c = splitPolygon( a, b ); + + // filter colinear points around the cuts + + a = filterPoints( a, a.next ); + c = filterPoints( c, c.next ); + + // run earcut on each half + + earcutLinked( a, triangles, dim, minX, minY, invSize ); + earcutLinked( c, triangles, dim, minX, minY, invSize ); + return; + + } + + b = b.next; + + } + + a = a.next; + + } while ( a !== start ); + + } + + // link every hole into the outer loop, producing a single-ring polygon without holes + + function eliminateHoles( data, holeIndices, outerNode, dim ) { + + var queue = [], i, len, start, end, list; + + for ( i = 0, len = holeIndices.length; i < len; i ++ ) { + + start = holeIndices[ i ] * dim; + end = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length; + list = linkedList( data, start, end, dim, false ); + if ( list === list.next ) list.steiner = true; + queue.push( getLeftmost( list ) ); + + } + + queue.sort( compareX ); + + // process holes from left to right + + for ( i = 0; i < queue.length; i ++ ) { + + eliminateHole( queue[ i ], outerNode ); + outerNode = filterPoints( outerNode, outerNode.next ); + + } + + return outerNode; + + } + + function compareX( a, b ) { + + return a.x - b.x; + + } + + // find a bridge between vertices that connects hole with an outer ring and and link it + + function eliminateHole( hole, outerNode ) { + + outerNode = findHoleBridge( hole, outerNode ); + + if ( outerNode ) { + + var b = splitPolygon( outerNode, hole ); + + filterPoints( b, b.next ); + + } + + } + + // David Eberly's algorithm for finding a bridge between hole and outer polygon + + function findHoleBridge( hole, outerNode ) { + + var p = outerNode, + hx = hole.x, + hy = hole.y, + qx = - Infinity, + m; + + // find a segment intersected by a ray from the hole's leftmost point to the left; + // segment's endpoint with lesser x will be potential connection point + + do { + + if ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) { + + var x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y ); + + if ( x <= hx && x > qx ) { + + qx = x; + + if ( x === hx ) { + + if ( hy === p.y ) return p; + if ( hy === p.next.y ) return p.next; + + } + + m = p.x < p.next.x ? p : p.next; + + } + + } + + p = p.next; + + } while ( p !== outerNode ); + + if ( ! m ) return null; + + if ( hx === qx ) return m.prev; // hole touches outer segment; pick lower endpoint + + // look for points inside the triangle of hole point, segment intersection and endpoint; + // if there are no points found, we have a valid connection; + // otherwise choose the point of the minimum angle with the ray as connection point + + var stop = m, + mx = m.x, + my = m.y, + tanMin = Infinity, + tan; + + p = m.next; + + while ( p !== stop ) { + + if ( hx >= p.x && p.x >= mx && hx !== p.x && + pointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) { + + tan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential + + if ( ( tan < tanMin || ( tan === tanMin && p.x > m.x ) ) && locallyInside( p, hole ) ) { + + m = p; + tanMin = tan; + + } + + } + + p = p.next; + + } + + return m; + + } + + // interlink polygon nodes in z-order + + function indexCurve( start, minX, minY, invSize ) { + + var p = start; + + do { + + if ( p.z === null ) p.z = zOrder( p.x, p.y, minX, minY, invSize ); + p.prevZ = p.prev; + p.nextZ = p.next; + p = p.next; + + } while ( p !== start ); + + p.prevZ.nextZ = null; + p.prevZ = null; + + sortLinked( p ); + + } + + // Simon Tatham's linked list merge sort algorithm + // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html + + function sortLinked( list ) { + + var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1; + + do { + + p = list; + list = null; + tail = null; + numMerges = 0; + + while ( p ) { + + numMerges ++; + q = p; + pSize = 0; + + for ( i = 0; i < inSize; i ++ ) { + + pSize ++; + q = q.nextZ; + if ( ! q ) break; + + } + + qSize = inSize; + + while ( pSize > 0 || ( qSize > 0 && q ) ) { + + if ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) { + + e = p; + p = p.nextZ; + pSize --; + + } else { + + e = q; + q = q.nextZ; + qSize --; + + } + + if ( tail ) tail.nextZ = e; + else list = e; + + e.prevZ = tail; + tail = e; + + } + + p = q; + + } + + tail.nextZ = null; + inSize *= 2; + + } while ( numMerges > 1 ); + + return list; + + } + + // z-order of a point given coords and inverse of the longer side of data bbox + + function zOrder( x, y, minX, minY, invSize ) { + + // coords are transformed into non-negative 15-bit integer range + + x = 32767 * ( x - minX ) * invSize; + y = 32767 * ( y - minY ) * invSize; + + x = ( x | ( x << 8 ) ) & 0x00FF00FF; + x = ( x | ( x << 4 ) ) & 0x0F0F0F0F; + x = ( x | ( x << 2 ) ) & 0x33333333; + x = ( x | ( x << 1 ) ) & 0x55555555; + + y = ( y | ( y << 8 ) ) & 0x00FF00FF; + y = ( y | ( y << 4 ) ) & 0x0F0F0F0F; + y = ( y | ( y << 2 ) ) & 0x33333333; + y = ( y | ( y << 1 ) ) & 0x55555555; + + return x | ( y << 1 ); + + } + + // find the leftmost node of a polygon ring + + function getLeftmost( start ) { + + var p = start, leftmost = start; + + do { + + if ( p.x < leftmost.x ) leftmost = p; + p = p.next; + + } while ( p !== start ); + + return leftmost; + + } + + // check if a point lies within a convex triangle + + function pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) { + + return ( cx - px ) * ( ay - py ) - ( ax - px ) * ( cy - py ) >= 0 && + ( ax - px ) * ( by - py ) - ( bx - px ) * ( ay - py ) >= 0 && + ( bx - px ) * ( cy - py ) - ( cx - px ) * ( by - py ) >= 0; + + } + + // check if a diagonal between two polygon nodes is valid (lies in polygon interior) + + function isValidDiagonal( a, b ) { + + return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) && + locallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b ); + + } + + // signed area of a triangle + + function area( p, q, r ) { + + return ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y ); + + } + + // check if two points are equal + + function equals( p1, p2 ) { + + return p1.x === p2.x && p1.y === p2.y; + + } + + // check if two segments intersect + + function intersects( p1, q1, p2, q2 ) { + + if ( ( equals( p1, q1 ) && equals( p2, q2 ) ) || + ( equals( p1, q2 ) && equals( p2, q1 ) ) ) return true; + + return area( p1, q1, p2 ) > 0 !== area( p1, q1, q2 ) > 0 && + area( p2, q2, p1 ) > 0 !== area( p2, q2, q1 ) > 0; + + } + + // check if a polygon diagonal intersects any polygon segments + + function intersectsPolygon( a, b ) { + + var p = a; + + do { + + if ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && + intersects( p, p.next, a, b ) ) { + + return true; + + } + + p = p.next; + + } while ( p !== a ); + + return false; + + } + + // check if a polygon diagonal is locally inside the polygon + + function locallyInside( a, b ) { + + return area( a.prev, a, a.next ) < 0 ? + area( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 : + area( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0; + + } + + // check if the middle point of a polygon diagonal is inside the polygon + + function middleInside( a, b ) { + + var p = a, + inside = false, + px = ( a.x + b.x ) / 2, + py = ( a.y + b.y ) / 2; + + do { + + if ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y && + ( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) ) { + + inside = ! inside; + + } + + p = p.next; + + } while ( p !== a ); + + return inside; + + } + + // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two; + // if one belongs to the outer ring and another to a hole, it merges it into a single ring + + function splitPolygon( a, b ) { + + var a2 = new Node( a.i, a.x, a.y ), + b2 = new Node( b.i, b.x, b.y ), + an = a.next, + bp = b.prev; + + a.next = b; + b.prev = a; + + a2.next = an; + an.prev = a2; + + b2.next = a2; + a2.prev = b2; + + bp.next = b2; + b2.prev = bp; + + return b2; + + } + + // create a node and optionally link it with previous one (in a circular doubly linked list) + + function insertNode( i, x, y, last ) { + + var p = new Node( i, x, y ); + + if ( ! last ) { + + p.prev = p; + p.next = p; + + } else { + + p.next = last.next; + p.prev = last; + last.next.prev = p; + last.next = p; + + } + + return p; + + } + + function removeNode( p ) { + + p.next.prev = p.prev; + p.prev.next = p.next; + + if ( p.prevZ ) p.prevZ.nextZ = p.nextZ; + if ( p.nextZ ) p.nextZ.prevZ = p.prevZ; + + } + + function Node( i, x, y ) { + + // vertice index in coordinates array + this.i = i; + + // vertex coordinates + this.x = x; + this.y = y; + + // previous and next vertice nodes in a polygon ring + this.prev = null; + this.next = null; + + // z-order curve value + this.z = null; + + // previous and next nodes in z-order + this.prevZ = null; + this.nextZ = null; + + // indicates whether this is a steiner point + this.steiner = false; + + } + + function signedArea( data, start, end, dim ) { + + var sum = 0; + + for ( var i = start, j = end - dim; i < end; i += dim ) { + + sum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] ); + j = i; + + } + + return sum; + + } + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + */ + + var ShapeUtils = { + + // calculate area of the contour polygon + + area: function ( contour ) { + + var n = contour.length; + var a = 0.0; + + for ( var p = n - 1, q = 0; q < n; p = q ++ ) { + + a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y; + + } + + return a * 0.5; + + }, + + isClockWise: function ( pts ) { + + return ShapeUtils.area( pts ) < 0; + + }, + + triangulateShape: function ( contour, holes ) { + + function removeDupEndPts( points ) { + + var l = points.length; + + if ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) { + + points.pop(); + + } + + } + + function addContour( vertices, contour ) { + + for ( var i = 0; i < contour.length; i ++ ) { + + vertices.push( contour[ i ].x ); + vertices.push( contour[ i ].y ); + + } + + } + + var vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ] + var holeIndices = []; // array of hole indices + var faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ] + + removeDupEndPts( contour ); + addContour( vertices, contour ); + + // + + var holeIndex = contour.length; + holes.forEach( removeDupEndPts ); + + for ( i = 0; i < holes.length; i ++ ) { + + holeIndices.push( holeIndex ); + holeIndex += holes[ i ].length; + addContour( vertices, holes[ i ] ); + + } + + // + + var triangles = Earcut.triangulate( vertices, holeIndices ); + + // + + for ( var i = 0; i < triangles.length; i += 3 ) { + + faces.push( triangles.slice( i, i + 3 ) ); + + } + + return faces; + + } + + }; + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * + * Creates extruded geometry from a path shape. + * + * parameters = { + * + * curveSegments: , // number of points on the curves + * steps: , // number of points for z-side extrusions / used for subdividing segments of extrude spline too + * amount: , // Depth to extrude the shape + * + * bevelEnabled: , // turn on bevel + * bevelThickness: , // how deep into the original shape bevel goes + * bevelSize: , // how far from shape outline is bevel + * bevelSegments: , // number of bevel layers + * + * extrudePath: // curve to extrude shape along + * frames: // containing arrays of tangents, normals, binormals + * + * UVGenerator: // object that provides UV generator functions + * + * } + */ + + // ExtrudeGeometry + + function ExtrudeGeometry( shapes, options ) { + + Geometry.call( this ); + + this.type = 'ExtrudeGeometry'; + + this.parameters = { + shapes: shapes, + options: options + }; + + this.fromBufferGeometry( new ExtrudeBufferGeometry( shapes, options ) ); + this.mergeVertices(); + + } + + ExtrudeGeometry.prototype = Object.create( Geometry.prototype ); + ExtrudeGeometry.prototype.constructor = ExtrudeGeometry; + + // ExtrudeBufferGeometry + + function ExtrudeBufferGeometry( shapes, options ) { + + if ( typeof ( shapes ) === "undefined" ) { + + return; + + } + + BufferGeometry.call( this ); + + this.type = 'ExtrudeBufferGeometry'; + + shapes = Array.isArray( shapes ) ? shapes : [ shapes ]; + + this.addShapeList( shapes, options ); + + this.computeVertexNormals(); + + // can't really use automatic vertex normals + // as then front and back sides get smoothed too + // should do separate smoothing just for sides + + //this.computeVertexNormals(); + + //console.log( "took", ( Date.now() - startTime ) ); + + } + + ExtrudeBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + ExtrudeBufferGeometry.prototype.constructor = ExtrudeBufferGeometry; + + ExtrudeBufferGeometry.prototype.getArrays = function () { + + var positionAttribute = this.getAttribute( "position" ); + var verticesArray = positionAttribute ? Array.prototype.slice.call( positionAttribute.array ) : []; + + var uvAttribute = this.getAttribute( "uv" ); + var uvArray = uvAttribute ? Array.prototype.slice.call( uvAttribute.array ) : []; + + var IndexAttribute = this.index; + var indicesArray = IndexAttribute ? Array.prototype.slice.call( IndexAttribute.array ) : []; + + return { + position: verticesArray, + uv: uvArray, + index: indicesArray + }; + + }; + + ExtrudeBufferGeometry.prototype.addShapeList = function ( shapes, options ) { + + var sl = shapes.length; + options.arrays = this.getArrays(); + + for ( var s = 0; s < sl; s ++ ) { + + var shape = shapes[ s ]; + this.addShape( shape, options ); + + } + + this.setIndex( options.arrays.index ); + this.addAttribute( 'position', new Float32BufferAttribute( options.arrays.position, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( options.arrays.uv, 2 ) ); + + }; + + ExtrudeBufferGeometry.prototype.addShape = function ( shape, options ) { + + var arrays = options.arrays ? options.arrays : this.getArrays(); + var verticesArray = arrays.position; + var indicesArray = arrays.index; + var uvArray = arrays.uv; + + var placeholder = []; + + + var amount = options.amount !== undefined ? options.amount : 100; + + var bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6; // 10 + var bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2; // 8 + var bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3; + + var bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true; // false + + var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12; + + var steps = options.steps !== undefined ? options.steps : 1; + + var extrudePath = options.extrudePath; + var extrudePts, extrudeByPath = false; + + // Use default WorldUVGenerator if no UV generators are specified. + var uvgen = options.UVGenerator !== undefined ? options.UVGenerator : ExtrudeGeometry.WorldUVGenerator; + + var splineTube, binormal, normal, position2; + if ( extrudePath ) { + + extrudePts = extrudePath.getSpacedPoints( steps ); + + extrudeByPath = true; + bevelEnabled = false; // bevels not supported for path extrusion + + // SETUP TNB variables + + // TODO1 - have a .isClosed in spline? + + splineTube = options.frames !== undefined ? options.frames : extrudePath.computeFrenetFrames( steps, false ); + + // console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length); + + binormal = new Vector3(); + normal = new Vector3(); + position2 = new Vector3(); + + } + + // Safeguards if bevels are not enabled + + if ( ! bevelEnabled ) { + + bevelSegments = 0; + bevelThickness = 0; + bevelSize = 0; + + } + + // Variables initialization + + var ahole, h, hl; // looping of holes + var scope = this; + + var shapePoints = shape.extractPoints( curveSegments ); + + var vertices = shapePoints.shape; + var holes = shapePoints.holes; + + var reverse = ! ShapeUtils.isClockWise( vertices ); + + if ( reverse ) { + + vertices = vertices.reverse(); + + // Maybe we should also check if holes are in the opposite direction, just to be safe ... + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + + if ( ShapeUtils.isClockWise( ahole ) ) { + + holes[ h ] = ahole.reverse(); + + } + + } + + } + + + var faces = ShapeUtils.triangulateShape( vertices, holes ); + + /* Vertices */ + + var contour = vertices; // vertices has all points but contour has only points of circumference + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + + vertices = vertices.concat( ahole ); + + } + + + function scalePt2( pt, vec, size ) { + + if ( ! vec ) console.error( "THREE.ExtrudeGeometry: vec does not exist" ); + + return vec.clone().multiplyScalar( size ).add( pt ); + + } + + var b, bs, t, z, + vert, vlen = vertices.length, + face, flen = faces.length; + + + // Find directions for point movement + + + function getBevelVec( inPt, inPrev, inNext ) { + + // computes for inPt the corresponding point inPt' on a new contour + // shifted by 1 unit (length of normalized vector) to the left + // if we walk along contour clockwise, this new contour is outside the old one + // + // inPt' is the intersection of the two lines parallel to the two + // adjacent edges of inPt at a distance of 1 unit on the left side. + + var v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt + + // good reading for geometry algorithms (here: line-line intersection) + // http://geomalgorithms.com/a05-_intersect-1.html + + var v_prev_x = inPt.x - inPrev.x, + v_prev_y = inPt.y - inPrev.y; + var v_next_x = inNext.x - inPt.x, + v_next_y = inNext.y - inPt.y; + + var v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y ); + + // check for collinear edges + var collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x ); + + if ( Math.abs( collinear0 ) > Number.EPSILON ) { + + // not collinear + + // length of vectors for normalizing + + var v_prev_len = Math.sqrt( v_prev_lensq ); + var v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y ); + + // shift adjacent points by unit vectors to the left + + var ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len ); + var ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len ); + + var ptNextShift_x = ( inNext.x - v_next_y / v_next_len ); + var ptNextShift_y = ( inNext.y + v_next_x / v_next_len ); + + // scaling factor for v_prev to intersection point + + var sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y - + ( ptNextShift_y - ptPrevShift_y ) * v_next_x ) / + ( v_prev_x * v_next_y - v_prev_y * v_next_x ); + + // vector from inPt to intersection point + + v_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x ); + v_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y ); + + // Don't normalize!, otherwise sharp corners become ugly + // but prevent crazy spikes + var v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y ); + if ( v_trans_lensq <= 2 ) { + + return new Vector2( v_trans_x, v_trans_y ); + + } else { + + shrink_by = Math.sqrt( v_trans_lensq / 2 ); + + } + + } else { + + // handle special case of collinear edges + + var direction_eq = false; // assumes: opposite + if ( v_prev_x > Number.EPSILON ) { + + if ( v_next_x > Number.EPSILON ) { + + direction_eq = true; + + } + + } else { + + if ( v_prev_x < - Number.EPSILON ) { + + if ( v_next_x < - Number.EPSILON ) { + + direction_eq = true; + + } + + } else { + + if ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) { + + direction_eq = true; + + } + + } + + } + + if ( direction_eq ) { + + // console.log("Warning: lines are a straight sequence"); + v_trans_x = - v_prev_y; + v_trans_y = v_prev_x; + shrink_by = Math.sqrt( v_prev_lensq ); + + } else { + + // console.log("Warning: lines are a straight spike"); + v_trans_x = v_prev_x; + v_trans_y = v_prev_y; + shrink_by = Math.sqrt( v_prev_lensq / 2 ); + + } + + } + + return new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by ); + + } + + + var contourMovements = []; + + for ( var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) { + + if ( j === il ) j = 0; + if ( k === il ) k = 0; + + // (j)---(i)---(k) + // console.log('i,j,k', i, j , k) + + contourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] ); + + } + + var holesMovements = [], + oneHoleMovements, verticesMovements = contourMovements.concat(); + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + + oneHoleMovements = []; + + for ( i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) { + + if ( j === il ) j = 0; + if ( k === il ) k = 0; + + // (j)---(i)---(k) + oneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] ); + + } + + holesMovements.push( oneHoleMovements ); + verticesMovements = verticesMovements.concat( oneHoleMovements ); + + } + + + // Loop bevelSegments, 1 for the front, 1 for the back + + for ( b = 0; b < bevelSegments; b ++ ) { + + //for ( b = bevelSegments; b > 0; b -- ) { + + t = b / bevelSegments; + z = bevelThickness * Math.cos( t * Math.PI / 2 ); + bs = bevelSize * Math.sin( t * Math.PI / 2 ); + + // contract shape + + for ( i = 0, il = contour.length; i < il; i ++ ) { + + vert = scalePt2( contour[ i ], contourMovements[ i ], bs ); + + v( vert.x, vert.y, - z ); + + } + + // expand holes + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + oneHoleMovements = holesMovements[ h ]; + + for ( i = 0, il = ahole.length; i < il; i ++ ) { + + vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs ); + + v( vert.x, vert.y, - z ); + + } + + } + + } + + bs = bevelSize; + + // Back facing vertices + + for ( i = 0; i < vlen; i ++ ) { + + vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ]; + + if ( ! extrudeByPath ) { + + v( vert.x, vert.y, 0 ); + + } else { + + // v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x ); + + normal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x ); + binormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y ); + + position2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal ); + + v( position2.x, position2.y, position2.z ); + + } + + } + + // Add stepped vertices... + // Including front facing vertices + + var s; + + for ( s = 1; s <= steps; s ++ ) { + + for ( i = 0; i < vlen; i ++ ) { + + vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ]; + + if ( ! extrudeByPath ) { + + v( vert.x, vert.y, amount / steps * s ); + + } else { + + // v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x ); + + normal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x ); + binormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y ); + + position2.copy( extrudePts[ s ] ).add( normal ).add( binormal ); + + v( position2.x, position2.y, position2.z ); + + } + + } + + } + + + // Add bevel segments planes + + //for ( b = 1; b <= bevelSegments; b ++ ) { + for ( b = bevelSegments - 1; b >= 0; b -- ) { + + t = b / bevelSegments; + z = bevelThickness * Math.cos( t * Math.PI / 2 ); + bs = bevelSize * Math.sin( t * Math.PI / 2 ); + + // contract shape + + for ( i = 0, il = contour.length; i < il; i ++ ) { + + vert = scalePt2( contour[ i ], contourMovements[ i ], bs ); + v( vert.x, vert.y, amount + z ); + + } + + // expand holes + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + oneHoleMovements = holesMovements[ h ]; + + for ( i = 0, il = ahole.length; i < il; i ++ ) { + + vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs ); + + if ( ! extrudeByPath ) { + + v( vert.x, vert.y, amount + z ); + + } else { + + v( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z ); + + } + + } + + } + + } + + /* Faces */ + + // Top and bottom faces + + buildLidFaces(); + + // Sides faces + + buildSideFaces(); + + + ///// Internal functions + + function buildLidFaces() { + + var start = verticesArray.length / 3; + + if ( bevelEnabled ) { + + var layer = 0; // steps + 1 + var offset = vlen * layer; + + // Bottom faces + + for ( i = 0; i < flen; i ++ ) { + + face = faces[ i ]; + f3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset ); + + } + + layer = steps + bevelSegments * 2; + offset = vlen * layer; + + // Top faces + + for ( i = 0; i < flen; i ++ ) { + + face = faces[ i ]; + f3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset ); + + } + + } else { + + // Bottom faces + + for ( i = 0; i < flen; i ++ ) { + + face = faces[ i ]; + f3( face[ 2 ], face[ 1 ], face[ 0 ] ); + + } + + // Top faces + + for ( i = 0; i < flen; i ++ ) { + + face = faces[ i ]; + f3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps ); + + } + + } + + scope.addGroup( start, verticesArray.length / 3 - start, options.material !== undefined ? options.material : 0 ); + + } + + // Create faces for the z-sides of the shape + + function buildSideFaces() { + + var start = verticesArray.length / 3; + var layeroffset = 0; + sidewalls( contour, layeroffset ); + layeroffset += contour.length; + + for ( h = 0, hl = holes.length; h < hl; h ++ ) { + + ahole = holes[ h ]; + sidewalls( ahole, layeroffset ); + + //, true + layeroffset += ahole.length; + + } + + + scope.addGroup( start, verticesArray.length / 3 - start, options.extrudeMaterial !== undefined ? options.extrudeMaterial : 1 ); + + + } + + function sidewalls( contour, layeroffset ) { + + var j, k; + i = contour.length; + + while ( -- i >= 0 ) { + + j = i; + k = i - 1; + if ( k < 0 ) k = contour.length - 1; + + //console.log('b', i,j, i-1, k,vertices.length); + + var s = 0, + sl = steps + bevelSegments * 2; + + for ( s = 0; s < sl; s ++ ) { + + var slen1 = vlen * s; + var slen2 = vlen * ( s + 1 ); + + var a = layeroffset + j + slen1, + b = layeroffset + k + slen1, + c = layeroffset + k + slen2, + d = layeroffset + j + slen2; + + f4( a, b, c, d ); + + } + + } + + } + + function v( x, y, z ) { + + placeholder.push( x ); + placeholder.push( y ); + placeholder.push( z ); + + } + + + function f3( a, b, c ) { + + addVertex( a ); + addVertex( b ); + addVertex( c ); + + var nextIndex = verticesArray.length / 3; + var uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 ); + + addUV( uvs[ 0 ] ); + addUV( uvs[ 1 ] ); + addUV( uvs[ 2 ] ); + + } + + function f4( a, b, c, d ) { + + addVertex( a ); + addVertex( b ); + addVertex( d ); + + addVertex( b ); + addVertex( c ); + addVertex( d ); + + + var nextIndex = verticesArray.length / 3; + var uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 ); + + addUV( uvs[ 0 ] ); + addUV( uvs[ 1 ] ); + addUV( uvs[ 3 ] ); + + addUV( uvs[ 1 ] ); + addUV( uvs[ 2 ] ); + addUV( uvs[ 3 ] ); + + } + + function addVertex( index ) { + + indicesArray.push( verticesArray.length / 3 ); + verticesArray.push( placeholder[ index * 3 + 0 ] ); + verticesArray.push( placeholder[ index * 3 + 1 ] ); + verticesArray.push( placeholder[ index * 3 + 2 ] ); + + } + + + function addUV( vector2 ) { + + uvArray.push( vector2.x ); + uvArray.push( vector2.y ); + + } + + if ( ! options.arrays ) { + + this.setIndex( indicesArray ); + this.addAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) ); + + } + + }; + + ExtrudeGeometry.WorldUVGenerator = { + + generateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) { + + var a_x = vertices[ indexA * 3 ]; + var a_y = vertices[ indexA * 3 + 1 ]; + var b_x = vertices[ indexB * 3 ]; + var b_y = vertices[ indexB * 3 + 1 ]; + var c_x = vertices[ indexC * 3 ]; + var c_y = vertices[ indexC * 3 + 1 ]; + + return [ + new Vector2( a_x, a_y ), + new Vector2( b_x, b_y ), + new Vector2( c_x, c_y ) + ]; + + }, + + generateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) { + + var a_x = vertices[ indexA * 3 ]; + var a_y = vertices[ indexA * 3 + 1 ]; + var a_z = vertices[ indexA * 3 + 2 ]; + var b_x = vertices[ indexB * 3 ]; + var b_y = vertices[ indexB * 3 + 1 ]; + var b_z = vertices[ indexB * 3 + 2 ]; + var c_x = vertices[ indexC * 3 ]; + var c_y = vertices[ indexC * 3 + 1 ]; + var c_z = vertices[ indexC * 3 + 2 ]; + var d_x = vertices[ indexD * 3 ]; + var d_y = vertices[ indexD * 3 + 1 ]; + var d_z = vertices[ indexD * 3 + 2 ]; + + if ( Math.abs( a_y - b_y ) < 0.01 ) { + + return [ + new Vector2( a_x, 1 - a_z ), + new Vector2( b_x, 1 - b_z ), + new Vector2( c_x, 1 - c_z ), + new Vector2( d_x, 1 - d_z ) + ]; + + } else { + + return [ + new Vector2( a_y, 1 - a_z ), + new Vector2( b_y, 1 - b_z ), + new Vector2( c_y, 1 - c_z ), + new Vector2( d_y, 1 - d_z ) + ]; + + } + + } + }; + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * @author alteredq / http://alteredqualia.com/ + * + * Text = 3D Text + * + * parameters = { + * font: , // font + * + * size: , // size of the text + * height: , // thickness to extrude text + * curveSegments: , // number of points on the curves + * + * bevelEnabled: , // turn on bevel + * bevelThickness: , // how deep into text bevel goes + * bevelSize: // how far from text outline is bevel + * } + */ + + // TextGeometry + + function TextGeometry( text, parameters ) { + + Geometry.call( this ); + + this.type = 'TextGeometry'; + + this.parameters = { + text: text, + parameters: parameters + }; + + this.fromBufferGeometry( new TextBufferGeometry( text, parameters ) ); + this.mergeVertices(); + + } + + TextGeometry.prototype = Object.create( Geometry.prototype ); + TextGeometry.prototype.constructor = TextGeometry; + + // TextBufferGeometry + + function TextBufferGeometry( text, parameters ) { + + parameters = parameters || {}; + + var font = parameters.font; + + if ( ! ( font && font.isFont ) ) { + + console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' ); + return new Geometry(); + + } + + var shapes = font.generateShapes( text, parameters.size, parameters.curveSegments ); + + // translate parameters to ExtrudeGeometry API + + parameters.amount = parameters.height !== undefined ? parameters.height : 50; + + // defaults + + if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10; + if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8; + if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false; + + ExtrudeBufferGeometry.call( this, shapes, parameters ); + + this.type = 'TextBufferGeometry'; + + } + + TextBufferGeometry.prototype = Object.create( ExtrudeBufferGeometry.prototype ); + TextBufferGeometry.prototype.constructor = TextBufferGeometry; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author benaadams / https://twitter.com/ben_a_adams + * @author Mugen87 / https://github.com/Mugen87 + */ + + // SphereGeometry + + function SphereGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) { + + Geometry.call( this ); + + this.type = 'SphereGeometry'; + + this.parameters = { + radius: radius, + widthSegments: widthSegments, + heightSegments: heightSegments, + phiStart: phiStart, + phiLength: phiLength, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + this.fromBufferGeometry( new SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) ); + this.mergeVertices(); + + } + + SphereGeometry.prototype = Object.create( Geometry.prototype ); + SphereGeometry.prototype.constructor = SphereGeometry; + + // SphereBufferGeometry + + function SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) { + + BufferGeometry.call( this ); + + this.type = 'SphereBufferGeometry'; + + this.parameters = { + radius: radius, + widthSegments: widthSegments, + heightSegments: heightSegments, + phiStart: phiStart, + phiLength: phiLength, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + radius = radius || 1; + + widthSegments = Math.max( 3, Math.floor( widthSegments ) || 8 ); + heightSegments = Math.max( 2, Math.floor( heightSegments ) || 6 ); + + phiStart = phiStart !== undefined ? phiStart : 0; + phiLength = phiLength !== undefined ? phiLength : Math.PI * 2; + + thetaStart = thetaStart !== undefined ? thetaStart : 0; + thetaLength = thetaLength !== undefined ? thetaLength : Math.PI; + + var thetaEnd = thetaStart + thetaLength; + + var ix, iy; + + var index = 0; + var grid = []; + + var vertex = new Vector3(); + var normal = new Vector3(); + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // generate vertices, normals and uvs + + for ( iy = 0; iy <= heightSegments; iy ++ ) { + + var verticesRow = []; + + var v = iy / heightSegments; + + for ( ix = 0; ix <= widthSegments; ix ++ ) { + + var u = ix / widthSegments; + + // vertex + + vertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength ); + vertex.y = radius * Math.cos( thetaStart + v * thetaLength ); + vertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength ); + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + normal.set( vertex.x, vertex.y, vertex.z ).normalize(); + normals.push( normal.x, normal.y, normal.z ); + + // uv + + uvs.push( u, 1 - v ); + + verticesRow.push( index ++ ); + + } + + grid.push( verticesRow ); + + } + + // indices + + for ( iy = 0; iy < heightSegments; iy ++ ) { + + for ( ix = 0; ix < widthSegments; ix ++ ) { + + var a = grid[ iy ][ ix + 1 ]; + var b = grid[ iy ][ ix ]; + var c = grid[ iy + 1 ][ ix ]; + var d = grid[ iy + 1 ][ ix + 1 ]; + + if ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d ); + if ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + SphereBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + SphereBufferGeometry.prototype.constructor = SphereBufferGeometry; + + /** + * @author Kaleb Murphy + * @author Mugen87 / https://github.com/Mugen87 + */ + + // RingGeometry + + function RingGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) { + + Geometry.call( this ); + + this.type = 'RingGeometry'; + + this.parameters = { + innerRadius: innerRadius, + outerRadius: outerRadius, + thetaSegments: thetaSegments, + phiSegments: phiSegments, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + this.fromBufferGeometry( new RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) ); + this.mergeVertices(); + + } + + RingGeometry.prototype = Object.create( Geometry.prototype ); + RingGeometry.prototype.constructor = RingGeometry; + + // RingBufferGeometry + + function RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) { + + BufferGeometry.call( this ); + + this.type = 'RingBufferGeometry'; + + this.parameters = { + innerRadius: innerRadius, + outerRadius: outerRadius, + thetaSegments: thetaSegments, + phiSegments: phiSegments, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + innerRadius = innerRadius || 0.5; + outerRadius = outerRadius || 1; + + thetaStart = thetaStart !== undefined ? thetaStart : 0; + thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2; + + thetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8; + phiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 1; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // some helper variables + + var segment; + var radius = innerRadius; + var radiusStep = ( ( outerRadius - innerRadius ) / phiSegments ); + var vertex = new Vector3(); + var uv = new Vector2(); + var j, i; + + // generate vertices, normals and uvs + + for ( j = 0; j <= phiSegments; j ++ ) { + + for ( i = 0; i <= thetaSegments; i ++ ) { + + // values are generate from the inside of the ring to the outside + + segment = thetaStart + i / thetaSegments * thetaLength; + + // vertex + + vertex.x = radius * Math.cos( segment ); + vertex.y = radius * Math.sin( segment ); + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + normals.push( 0, 0, 1 ); + + // uv + + uv.x = ( vertex.x / outerRadius + 1 ) / 2; + uv.y = ( vertex.y / outerRadius + 1 ) / 2; + + uvs.push( uv.x, uv.y ); + + } + + // increase the radius for next row of vertices + + radius += radiusStep; + + } + + // indices + + for ( j = 0; j < phiSegments; j ++ ) { + + var thetaSegmentLevel = j * ( thetaSegments + 1 ); + + for ( i = 0; i < thetaSegments; i ++ ) { + + segment = i + thetaSegmentLevel; + + var a = segment; + var b = segment + thetaSegments + 1; + var c = segment + thetaSegments + 2; + var d = segment + 1; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + RingBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + RingBufferGeometry.prototype.constructor = RingBufferGeometry; + + /** + * @author astrodud / http://astrodud.isgreat.org/ + * @author zz85 / https://github.com/zz85 + * @author bhouston / http://clara.io + * @author Mugen87 / https://github.com/Mugen87 + */ + + // LatheGeometry + + function LatheGeometry( points, segments, phiStart, phiLength ) { + + Geometry.call( this ); + + this.type = 'LatheGeometry'; + + this.parameters = { + points: points, + segments: segments, + phiStart: phiStart, + phiLength: phiLength + }; + + this.fromBufferGeometry( new LatheBufferGeometry( points, segments, phiStart, phiLength ) ); + this.mergeVertices(); + + } + + LatheGeometry.prototype = Object.create( Geometry.prototype ); + LatheGeometry.prototype.constructor = LatheGeometry; + + // LatheBufferGeometry + + function LatheBufferGeometry( points, segments, phiStart, phiLength ) { + + BufferGeometry.call( this ); + + this.type = 'LatheBufferGeometry'; + + this.parameters = { + points: points, + segments: segments, + phiStart: phiStart, + phiLength: phiLength + }; + + segments = Math.floor( segments ) || 12; + phiStart = phiStart || 0; + phiLength = phiLength || Math.PI * 2; + + // clamp phiLength so it's in range of [ 0, 2PI ] + + phiLength = _Math.clamp( phiLength, 0, Math.PI * 2 ); + + + // buffers + + var indices = []; + var vertices = []; + var uvs = []; + + // helper variables + + var base; + var inverseSegments = 1.0 / segments; + var vertex = new Vector3(); + var uv = new Vector2(); + var i, j; + + // generate vertices and uvs + + for ( i = 0; i <= segments; i ++ ) { + + var phi = phiStart + i * inverseSegments * phiLength; + + var sin = Math.sin( phi ); + var cos = Math.cos( phi ); + + for ( j = 0; j <= ( points.length - 1 ); j ++ ) { + + // vertex + + vertex.x = points[ j ].x * sin; + vertex.y = points[ j ].y; + vertex.z = points[ j ].x * cos; + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // uv + + uv.x = i / segments; + uv.y = j / ( points.length - 1 ); + + uvs.push( uv.x, uv.y ); + + + } + + } + + // indices + + for ( i = 0; i < segments; i ++ ) { + + for ( j = 0; j < ( points.length - 1 ); j ++ ) { + + base = j + i * points.length; + + var a = base; + var b = base + points.length; + var c = base + points.length + 1; + var d = base + 1; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + // generate normals + + this.computeVertexNormals(); + + // if the geometry is closed, we need to average the normals along the seam. + // because the corresponding vertices are identical (but still have different UVs). + + if ( phiLength === Math.PI * 2 ) { + + var normals = this.attributes.normal.array; + var n1 = new Vector3(); + var n2 = new Vector3(); + var n = new Vector3(); + + // this is the buffer offset for the last line of vertices + + base = segments * points.length * 3; + + for ( i = 0, j = 0; i < points.length; i ++, j += 3 ) { + + // select the normal of the vertex in the first line + + n1.x = normals[ j + 0 ]; + n1.y = normals[ j + 1 ]; + n1.z = normals[ j + 2 ]; + + // select the normal of the vertex in the last line + + n2.x = normals[ base + j + 0 ]; + n2.y = normals[ base + j + 1 ]; + n2.z = normals[ base + j + 2 ]; + + // average normals + + n.addVectors( n1, n2 ).normalize(); + + // assign the new values to both normals + + normals[ j + 0 ] = normals[ base + j + 0 ] = n.x; + normals[ j + 1 ] = normals[ base + j + 1 ] = n.y; + normals[ j + 2 ] = normals[ base + j + 2 ] = n.z; + + } + + } + + } + + LatheBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + LatheBufferGeometry.prototype.constructor = LatheBufferGeometry; + + /** + * @author jonobr1 / http://jonobr1.com + * @author Mugen87 / https://github.com/Mugen87 + */ + + // ShapeGeometry + + function ShapeGeometry( shapes, curveSegments ) { + + Geometry.call( this ); + + this.type = 'ShapeGeometry'; + + if ( typeof curveSegments === 'object' ) { + + console.warn( 'THREE.ShapeGeometry: Options parameter has been removed.' ); + + curveSegments = curveSegments.curveSegments; + + } + + this.parameters = { + shapes: shapes, + curveSegments: curveSegments + }; + + this.fromBufferGeometry( new ShapeBufferGeometry( shapes, curveSegments ) ); + this.mergeVertices(); + + } + + ShapeGeometry.prototype = Object.create( Geometry.prototype ); + ShapeGeometry.prototype.constructor = ShapeGeometry; + + ShapeGeometry.prototype.toJSON = function () { + + var data = Geometry.prototype.toJSON.call( this ); + + var shapes = this.parameters.shapes; + + return toJSON( shapes, data ); + + }; + + // ShapeBufferGeometry + + function ShapeBufferGeometry( shapes, curveSegments ) { + + BufferGeometry.call( this ); + + this.type = 'ShapeBufferGeometry'; + + this.parameters = { + shapes: shapes, + curveSegments: curveSegments + }; + + curveSegments = curveSegments || 12; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var groupStart = 0; + var groupCount = 0; + + // allow single and array values for "shapes" parameter + + if ( Array.isArray( shapes ) === false ) { + + addShape( shapes ); + + } else { + + for ( var i = 0; i < shapes.length; i ++ ) { + + addShape( shapes[ i ] ); + + this.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support + + groupStart += groupCount; + groupCount = 0; + + } + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + + // helper functions + + function addShape( shape ) { + + var i, l, shapeHole; + + var indexOffset = vertices.length / 3; + var points = shape.extractPoints( curveSegments ); + + var shapeVertices = points.shape; + var shapeHoles = points.holes; + + // check direction of vertices + + if ( ShapeUtils.isClockWise( shapeVertices ) === false ) { + + shapeVertices = shapeVertices.reverse(); + + // also check if holes are in the opposite direction + + for ( i = 0, l = shapeHoles.length; i < l; i ++ ) { + + shapeHole = shapeHoles[ i ]; + + if ( ShapeUtils.isClockWise( shapeHole ) === true ) { + + shapeHoles[ i ] = shapeHole.reverse(); + + } + + } + + } + + var faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles ); + + // join vertices of inner and outer paths to a single array + + for ( i = 0, l = shapeHoles.length; i < l; i ++ ) { + + shapeHole = shapeHoles[ i ]; + shapeVertices = shapeVertices.concat( shapeHole ); + + } + + // vertices, normals, uvs + + for ( i = 0, l = shapeVertices.length; i < l; i ++ ) { + + var vertex = shapeVertices[ i ]; + + vertices.push( vertex.x, vertex.y, 0 ); + normals.push( 0, 0, 1 ); + uvs.push( vertex.x, vertex.y ); // world uvs + + } + + // incides + + for ( i = 0, l = faces.length; i < l; i ++ ) { + + var face = faces[ i ]; + + var a = face[ 0 ] + indexOffset; + var b = face[ 1 ] + indexOffset; + var c = face[ 2 ] + indexOffset; + + indices.push( a, b, c ); + groupCount += 3; + + } + + } + + } + + ShapeBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + ShapeBufferGeometry.prototype.constructor = ShapeBufferGeometry; + + ShapeBufferGeometry.prototype.toJSON = function () { + + var data = BufferGeometry.prototype.toJSON.call( this ); + + var shapes = this.parameters.shapes; + + return toJSON( shapes, data ); + + }; + + // + + function toJSON( shapes, data ) { + + data.shapes = []; + + if ( Array.isArray( shapes ) ) { + + for ( var i = 0, l = shapes.length; i < l; i ++ ) { + + var shape = shapes[ i ]; + + data.shapes.push( shape.uuid ); + + } + + } else { + + data.shapes.push( shapes.uuid ); + + } + + return data; + + } + + /** + * @author WestLangley / http://github.com/WestLangley + * @author Mugen87 / https://github.com/Mugen87 + */ + + function EdgesGeometry( geometry, thresholdAngle ) { + + BufferGeometry.call( this ); + + this.type = 'EdgesGeometry'; + + this.parameters = { + thresholdAngle: thresholdAngle + }; + + thresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1; + + // buffer + + var vertices = []; + + // helper variables + + var thresholdDot = Math.cos( _Math.DEG2RAD * thresholdAngle ); + var edge = [ 0, 0 ], edges = {}, edge1, edge2; + var key, keys = [ 'a', 'b', 'c' ]; + + // prepare source geometry + + var geometry2; + + if ( geometry.isBufferGeometry ) { + + geometry2 = new Geometry(); + geometry2.fromBufferGeometry( geometry ); + + } else { + + geometry2 = geometry.clone(); + + } + + geometry2.mergeVertices(); + geometry2.computeFaceNormals(); + + var sourceVertices = geometry2.vertices; + var faces = geometry2.faces; + + // now create a data structure where each entry represents an edge with its adjoining faces + + for ( var i = 0, l = faces.length; i < l; i ++ ) { + + var face = faces[ i ]; + + for ( var j = 0; j < 3; j ++ ) { + + edge1 = face[ keys[ j ] ]; + edge2 = face[ keys[ ( j + 1 ) % 3 ] ]; + edge[ 0 ] = Math.min( edge1, edge2 ); + edge[ 1 ] = Math.max( edge1, edge2 ); + + key = edge[ 0 ] + ',' + edge[ 1 ]; + + if ( edges[ key ] === undefined ) { + + edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ], face1: i, face2: undefined }; + + } else { + + edges[ key ].face2 = i; + + } + + } + + } + + // generate vertices + + for ( key in edges ) { + + var e = edges[ key ]; + + // an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree. + + if ( e.face2 === undefined || faces[ e.face1 ].normal.dot( faces[ e.face2 ].normal ) <= thresholdDot ) { + + var vertex = sourceVertices[ e.index1 ]; + vertices.push( vertex.x, vertex.y, vertex.z ); + + vertex = sourceVertices[ e.index2 ]; + vertices.push( vertex.x, vertex.y, vertex.z ); + + } + + } + + // build geometry + + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + + } + + EdgesGeometry.prototype = Object.create( BufferGeometry.prototype ); + EdgesGeometry.prototype.constructor = EdgesGeometry; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + // CylinderGeometry + + function CylinderGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) { + + Geometry.call( this ); + + this.type = 'CylinderGeometry'; + + this.parameters = { + radiusTop: radiusTop, + radiusBottom: radiusBottom, + height: height, + radialSegments: radialSegments, + heightSegments: heightSegments, + openEnded: openEnded, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + this.fromBufferGeometry( new CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) ); + this.mergeVertices(); + + } + + CylinderGeometry.prototype = Object.create( Geometry.prototype ); + CylinderGeometry.prototype.constructor = CylinderGeometry; + + // CylinderBufferGeometry + + function CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) { + + BufferGeometry.call( this ); + + this.type = 'CylinderBufferGeometry'; + + this.parameters = { + radiusTop: radiusTop, + radiusBottom: radiusBottom, + height: height, + radialSegments: radialSegments, + heightSegments: heightSegments, + openEnded: openEnded, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + var scope = this; + + radiusTop = radiusTop !== undefined ? radiusTop : 1; + radiusBottom = radiusBottom !== undefined ? radiusBottom : 1; + height = height || 1; + + radialSegments = Math.floor( radialSegments ) || 8; + heightSegments = Math.floor( heightSegments ) || 1; + + openEnded = openEnded !== undefined ? openEnded : false; + thetaStart = thetaStart !== undefined ? thetaStart : 0.0; + thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var index = 0; + var indexArray = []; + var halfHeight = height / 2; + var groupStart = 0; + + // generate geometry + + generateTorso(); + + if ( openEnded === false ) { + + if ( radiusTop > 0 ) generateCap( true ); + if ( radiusBottom > 0 ) generateCap( false ); + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + function generateTorso() { + + var x, y; + var normal = new Vector3(); + var vertex = new Vector3(); + + var groupCount = 0; + + // this will be used to calculate the normal + var slope = ( radiusBottom - radiusTop ) / height; + + // generate vertices, normals and uvs + + for ( y = 0; y <= heightSegments; y ++ ) { + + var indexRow = []; + + var v = y / heightSegments; + + // calculate the radius of the current row + + var radius = v * ( radiusBottom - radiusTop ) + radiusTop; + + for ( x = 0; x <= radialSegments; x ++ ) { + + var u = x / radialSegments; + + var theta = u * thetaLength + thetaStart; + + var sinTheta = Math.sin( theta ); + var cosTheta = Math.cos( theta ); + + // vertex + + vertex.x = radius * sinTheta; + vertex.y = - v * height + halfHeight; + vertex.z = radius * cosTheta; + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + normal.set( sinTheta, slope, cosTheta ).normalize(); + normals.push( normal.x, normal.y, normal.z ); + + // uv + + uvs.push( u, 1 - v ); + + // save index of vertex in respective row + + indexRow.push( index ++ ); + + } + + // now save vertices of the row in our index array + + indexArray.push( indexRow ); + + } + + // generate indices + + for ( x = 0; x < radialSegments; x ++ ) { + + for ( y = 0; y < heightSegments; y ++ ) { + + // we use the index array to access the correct indices + + var a = indexArray[ y ][ x ]; + var b = indexArray[ y + 1 ][ x ]; + var c = indexArray[ y + 1 ][ x + 1 ]; + var d = indexArray[ y ][ x + 1 ]; + + // faces + + indices.push( a, b, d ); + indices.push( b, c, d ); + + // update group counter + + groupCount += 6; + + } + + } + + // add a group to the geometry. this will ensure multi material support + + scope.addGroup( groupStart, groupCount, 0 ); + + // calculate new start value for groups + + groupStart += groupCount; + + } + + function generateCap( top ) { + + var x, centerIndexStart, centerIndexEnd; + + var uv = new Vector2(); + var vertex = new Vector3(); + + var groupCount = 0; + + var radius = ( top === true ) ? radiusTop : radiusBottom; + var sign = ( top === true ) ? 1 : - 1; + + // save the index of the first center vertex + centerIndexStart = index; + + // first we generate the center vertex data of the cap. + // because the geometry needs one set of uvs per face, + // we must generate a center vertex per face/segment + + for ( x = 1; x <= radialSegments; x ++ ) { + + // vertex + + vertices.push( 0, halfHeight * sign, 0 ); + + // normal + + normals.push( 0, sign, 0 ); + + // uv + + uvs.push( 0.5, 0.5 ); + + // increase index + + index ++; + + } + + // save the index of the last center vertex + + centerIndexEnd = index; + + // now we generate the surrounding vertices, normals and uvs + + for ( x = 0; x <= radialSegments; x ++ ) { + + var u = x / radialSegments; + var theta = u * thetaLength + thetaStart; + + var cosTheta = Math.cos( theta ); + var sinTheta = Math.sin( theta ); + + // vertex + + vertex.x = radius * sinTheta; + vertex.y = halfHeight * sign; + vertex.z = radius * cosTheta; + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + normals.push( 0, sign, 0 ); + + // uv + + uv.x = ( cosTheta * 0.5 ) + 0.5; + uv.y = ( sinTheta * 0.5 * sign ) + 0.5; + uvs.push( uv.x, uv.y ); + + // increase index + + index ++; + + } + + // generate indices + + for ( x = 0; x < radialSegments; x ++ ) { + + var c = centerIndexStart + x; + var i = centerIndexEnd + x; + + if ( top === true ) { + + // face top + + indices.push( i, i + 1, c ); + + } else { + + // face bottom + + indices.push( i + 1, i, c ); + + } + + groupCount += 3; + + } + + // add a group to the geometry. this will ensure multi material support + + scope.addGroup( groupStart, groupCount, top === true ? 1 : 2 ); + + // calculate new start value for groups + + groupStart += groupCount; + + } + + } + + CylinderBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + CylinderBufferGeometry.prototype.constructor = CylinderBufferGeometry; + + /** + * @author abelnation / http://github.com/abelnation + */ + + // ConeGeometry + + function ConeGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) { + + CylinderGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ); + + this.type = 'ConeGeometry'; + + this.parameters = { + radius: radius, + height: height, + radialSegments: radialSegments, + heightSegments: heightSegments, + openEnded: openEnded, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + } + + ConeGeometry.prototype = Object.create( CylinderGeometry.prototype ); + ConeGeometry.prototype.constructor = ConeGeometry; + + // ConeBufferGeometry + + function ConeBufferGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) { + + CylinderBufferGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ); + + this.type = 'ConeBufferGeometry'; + + this.parameters = { + radius: radius, + height: height, + radialSegments: radialSegments, + heightSegments: heightSegments, + openEnded: openEnded, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + } + + ConeBufferGeometry.prototype = Object.create( CylinderBufferGeometry.prototype ); + ConeBufferGeometry.prototype.constructor = ConeBufferGeometry; + + /** + * @author benaadams / https://twitter.com/ben_a_adams + * @author Mugen87 / https://github.com/Mugen87 + * @author hughes + */ + + // CircleGeometry + + function CircleGeometry( radius, segments, thetaStart, thetaLength ) { + + Geometry.call( this ); + + this.type = 'CircleGeometry'; + + this.parameters = { + radius: radius, + segments: segments, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + this.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) ); + this.mergeVertices(); + + } + + CircleGeometry.prototype = Object.create( Geometry.prototype ); + CircleGeometry.prototype.constructor = CircleGeometry; + + // CircleBufferGeometry + + function CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) { + + BufferGeometry.call( this ); + + this.type = 'CircleBufferGeometry'; + + this.parameters = { + radius: radius, + segments: segments, + thetaStart: thetaStart, + thetaLength: thetaLength + }; + + radius = radius || 1; + segments = segments !== undefined ? Math.max( 3, segments ) : 8; + + thetaStart = thetaStart !== undefined ? thetaStart : 0; + thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2; + + // buffers + + var indices = []; + var vertices = []; + var normals = []; + var uvs = []; + + // helper variables + + var i, s; + var vertex = new Vector3(); + var uv = new Vector2(); + + // center point + + vertices.push( 0, 0, 0 ); + normals.push( 0, 0, 1 ); + uvs.push( 0.5, 0.5 ); + + for ( s = 0, i = 3; s <= segments; s ++, i += 3 ) { + + var segment = thetaStart + s / segments * thetaLength; + + // vertex + + vertex.x = radius * Math.cos( segment ); + vertex.y = radius * Math.sin( segment ); + + vertices.push( vertex.x, vertex.y, vertex.z ); + + // normal + + normals.push( 0, 0, 1 ); + + // uvs + + uv.x = ( vertices[ i ] / radius + 1 ) / 2; + uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2; + + uvs.push( uv.x, uv.y ); + + } + + // indices + + for ( i = 1; i <= segments; i ++ ) { + + indices.push( i, i + 1, 0 ); + + } + + // build geometry + + this.setIndex( indices ); + this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) ); + this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) ); + + } + + CircleBufferGeometry.prototype = Object.create( BufferGeometry.prototype ); + CircleBufferGeometry.prototype.constructor = CircleBufferGeometry; + + + + var Geometries = Object.freeze({ + WireframeGeometry: WireframeGeometry, + ParametricGeometry: ParametricGeometry, + ParametricBufferGeometry: ParametricBufferGeometry, + TetrahedronGeometry: TetrahedronGeometry, + TetrahedronBufferGeometry: TetrahedronBufferGeometry, + OctahedronGeometry: OctahedronGeometry, + OctahedronBufferGeometry: OctahedronBufferGeometry, + IcosahedronGeometry: IcosahedronGeometry, + IcosahedronBufferGeometry: IcosahedronBufferGeometry, + DodecahedronGeometry: DodecahedronGeometry, + DodecahedronBufferGeometry: DodecahedronBufferGeometry, + PolyhedronGeometry: PolyhedronGeometry, + PolyhedronBufferGeometry: PolyhedronBufferGeometry, + TubeGeometry: TubeGeometry, + TubeBufferGeometry: TubeBufferGeometry, + TorusKnotGeometry: TorusKnotGeometry, + TorusKnotBufferGeometry: TorusKnotBufferGeometry, + TorusGeometry: TorusGeometry, + TorusBufferGeometry: TorusBufferGeometry, + TextGeometry: TextGeometry, + TextBufferGeometry: TextBufferGeometry, + SphereGeometry: SphereGeometry, + SphereBufferGeometry: SphereBufferGeometry, + RingGeometry: RingGeometry, + RingBufferGeometry: RingBufferGeometry, + PlaneGeometry: PlaneGeometry, + PlaneBufferGeometry: PlaneBufferGeometry, + LatheGeometry: LatheGeometry, + LatheBufferGeometry: LatheBufferGeometry, + ShapeGeometry: ShapeGeometry, + ShapeBufferGeometry: ShapeBufferGeometry, + ExtrudeGeometry: ExtrudeGeometry, + ExtrudeBufferGeometry: ExtrudeBufferGeometry, + EdgesGeometry: EdgesGeometry, + ConeGeometry: ConeGeometry, + ConeBufferGeometry: ConeBufferGeometry, + CylinderGeometry: CylinderGeometry, + CylinderBufferGeometry: CylinderBufferGeometry, + CircleGeometry: CircleGeometry, + CircleBufferGeometry: CircleBufferGeometry, + BoxGeometry: BoxGeometry, + BoxBufferGeometry: BoxBufferGeometry + }); + + /** + * @author mrdoob / http://mrdoob.com/ + * + * parameters = { + * color: , + * opacity: + * } + */ + + function ShadowMaterial( parameters ) { + + Material.call( this ); + + this.type = 'ShadowMaterial'; + + this.color = new Color( 0x000000 ); + this.opacity = 1.0; + + this.lights = true; + this.transparent = true; + + this.setValues( parameters ); + + } + + ShadowMaterial.prototype = Object.create( Material.prototype ); + ShadowMaterial.prototype.constructor = ShadowMaterial; + + ShadowMaterial.prototype.isShadowMaterial = true; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function RawShaderMaterial( parameters ) { + + ShaderMaterial.call( this, parameters ); + + this.type = 'RawShaderMaterial'; + + } + + RawShaderMaterial.prototype = Object.create( ShaderMaterial.prototype ); + RawShaderMaterial.prototype.constructor = RawShaderMaterial; + + RawShaderMaterial.prototype.isRawShaderMaterial = true; + + /** + * @author WestLangley / http://github.com/WestLangley + * + * parameters = { + * color: , + * roughness: , + * metalness: , + * opacity: , + * + * map: new THREE.Texture( ), + * + * lightMap: new THREE.Texture( ), + * lightMapIntensity: + * + * aoMap: new THREE.Texture( ), + * aoMapIntensity: + * + * emissive: , + * emissiveIntensity: + * emissiveMap: new THREE.Texture( ), + * + * bumpMap: new THREE.Texture( ), + * bumpScale: , + * + * normalMap: new THREE.Texture( ), + * normalScale: , + * + * displacementMap: new THREE.Texture( ), + * displacementScale: , + * displacementBias: , + * + * roughnessMap: new THREE.Texture( ), + * + * metalnessMap: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ), + * envMapIntensity: + * + * refractionRatio: , + * + * wireframe: , + * wireframeLinewidth: , + * + * skinning: , + * morphTargets: , + * morphNormals: + * } + */ + + function MeshStandardMaterial( parameters ) { + + Material.call( this ); + + this.defines = { 'STANDARD': '' }; + + this.type = 'MeshStandardMaterial'; + + this.color = new Color( 0xffffff ); // diffuse + this.roughness = 0.5; + this.metalness = 0.5; + + this.map = null; + + this.lightMap = null; + this.lightMapIntensity = 1.0; + + this.aoMap = null; + this.aoMapIntensity = 1.0; + + this.emissive = new Color( 0x000000 ); + this.emissiveIntensity = 1.0; + this.emissiveMap = null; + + this.bumpMap = null; + this.bumpScale = 1; + + this.normalMap = null; + this.normalScale = new Vector2( 1, 1 ); + + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + + this.roughnessMap = null; + + this.metalnessMap = null; + + this.alphaMap = null; + + this.envMap = null; + this.envMapIntensity = 1.0; + + this.refractionRatio = 0.98; + + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = 'round'; + this.wireframeLinejoin = 'round'; + + this.skinning = false; + this.morphTargets = false; + this.morphNormals = false; + + this.setValues( parameters ); + + } + + MeshStandardMaterial.prototype = Object.create( Material.prototype ); + MeshStandardMaterial.prototype.constructor = MeshStandardMaterial; + + MeshStandardMaterial.prototype.isMeshStandardMaterial = true; + + MeshStandardMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.defines = { 'STANDARD': '' }; + + this.color.copy( source.color ); + this.roughness = source.roughness; + this.metalness = source.metalness; + + this.map = source.map; + + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + + this.emissive.copy( source.emissive ); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + + this.normalMap = source.normalMap; + this.normalScale.copy( source.normalScale ); + + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + + this.roughnessMap = source.roughnessMap; + + this.metalnessMap = source.metalnessMap; + + this.alphaMap = source.alphaMap; + + this.envMap = source.envMap; + this.envMapIntensity = source.envMapIntensity; + + this.refractionRatio = source.refractionRatio; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + this.morphNormals = source.morphNormals; + + return this; + + }; + + /** + * @author WestLangley / http://github.com/WestLangley + * + * parameters = { + * reflectivity: + * } + */ + + function MeshPhysicalMaterial( parameters ) { + + MeshStandardMaterial.call( this ); + + this.defines = { 'PHYSICAL': '' }; + + this.type = 'MeshPhysicalMaterial'; + + this.reflectivity = 0.5; // maps to F0 = 0.04 + + this.clearCoat = 0.0; + this.clearCoatRoughness = 0.0; + + this.setValues( parameters ); + + } + + MeshPhysicalMaterial.prototype = Object.create( MeshStandardMaterial.prototype ); + MeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial; + + MeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true; + + MeshPhysicalMaterial.prototype.copy = function ( source ) { + + MeshStandardMaterial.prototype.copy.call( this, source ); + + this.defines = { 'PHYSICAL': '' }; + + this.reflectivity = source.reflectivity; + + this.clearCoat = source.clearCoat; + this.clearCoatRoughness = source.clearCoatRoughness; + + return this; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * specular: , + * shininess: , + * opacity: , + * + * map: new THREE.Texture( ), + * + * lightMap: new THREE.Texture( ), + * lightMapIntensity: + * + * aoMap: new THREE.Texture( ), + * aoMapIntensity: + * + * emissive: , + * emissiveIntensity: + * emissiveMap: new THREE.Texture( ), + * + * bumpMap: new THREE.Texture( ), + * bumpScale: , + * + * normalMap: new THREE.Texture( ), + * normalScale: , + * + * displacementMap: new THREE.Texture( ), + * displacementScale: , + * displacementBias: , + * + * specularMap: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), + * combine: THREE.Multiply, + * reflectivity: , + * refractionRatio: , + * + * wireframe: , + * wireframeLinewidth: , + * + * skinning: , + * morphTargets: , + * morphNormals: + * } + */ + + function MeshPhongMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshPhongMaterial'; + + this.color = new Color( 0xffffff ); // diffuse + this.specular = new Color( 0x111111 ); + this.shininess = 30; + + this.map = null; + + this.lightMap = null; + this.lightMapIntensity = 1.0; + + this.aoMap = null; + this.aoMapIntensity = 1.0; + + this.emissive = new Color( 0x000000 ); + this.emissiveIntensity = 1.0; + this.emissiveMap = null; + + this.bumpMap = null; + this.bumpScale = 1; + + this.normalMap = null; + this.normalScale = new Vector2( 1, 1 ); + + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + + this.specularMap = null; + + this.alphaMap = null; + + this.envMap = null; + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = 'round'; + this.wireframeLinejoin = 'round'; + + this.skinning = false; + this.morphTargets = false; + this.morphNormals = false; + + this.setValues( parameters ); + + } + + MeshPhongMaterial.prototype = Object.create( Material.prototype ); + MeshPhongMaterial.prototype.constructor = MeshPhongMaterial; + + MeshPhongMaterial.prototype.isMeshPhongMaterial = true; + + MeshPhongMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + this.specular.copy( source.specular ); + this.shininess = source.shininess; + + this.map = source.map; + + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + + this.emissive.copy( source.emissive ); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + + this.normalMap = source.normalMap; + this.normalScale.copy( source.normalScale ); + + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + + this.specularMap = source.specularMap; + + this.alphaMap = source.alphaMap; + + this.envMap = source.envMap; + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + this.morphNormals = source.morphNormals; + + return this; + + }; + + /** + * @author takahirox / http://github.com/takahirox + * + * parameters = { + * gradientMap: new THREE.Texture( ) + * } + */ + + function MeshToonMaterial( parameters ) { + + MeshPhongMaterial.call( this ); + + this.defines = { 'TOON': '' }; + + this.type = 'MeshToonMaterial'; + + this.gradientMap = null; + + this.setValues( parameters ); + + } + + MeshToonMaterial.prototype = Object.create( MeshPhongMaterial.prototype ); + MeshToonMaterial.prototype.constructor = MeshToonMaterial; + + MeshToonMaterial.prototype.isMeshToonMaterial = true; + + MeshToonMaterial.prototype.copy = function ( source ) { + + MeshPhongMaterial.prototype.copy.call( this, source ); + + this.gradientMap = source.gradientMap; + + return this; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + * + * parameters = { + * opacity: , + * + * bumpMap: new THREE.Texture( ), + * bumpScale: , + * + * normalMap: new THREE.Texture( ), + * normalScale: , + * + * displacementMap: new THREE.Texture( ), + * displacementScale: , + * displacementBias: , + * + * wireframe: , + * wireframeLinewidth: + * + * skinning: , + * morphTargets: , + * morphNormals: + * } + */ + + function MeshNormalMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshNormalMaterial'; + + this.bumpMap = null; + this.bumpScale = 1; + + this.normalMap = null; + this.normalScale = new Vector2( 1, 1 ); + + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + + this.wireframe = false; + this.wireframeLinewidth = 1; + + this.fog = false; + this.lights = false; + + this.skinning = false; + this.morphTargets = false; + this.morphNormals = false; + + this.setValues( parameters ); + + } + + MeshNormalMaterial.prototype = Object.create( Material.prototype ); + MeshNormalMaterial.prototype.constructor = MeshNormalMaterial; + + MeshNormalMaterial.prototype.isMeshNormalMaterial = true; + + MeshNormalMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + + this.normalMap = source.normalMap; + this.normalScale.copy( source.normalScale ); + + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + this.morphNormals = source.morphNormals; + + return this; + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * + * map: new THREE.Texture( ), + * + * lightMap: new THREE.Texture( ), + * lightMapIntensity: + * + * aoMap: new THREE.Texture( ), + * aoMapIntensity: + * + * emissive: , + * emissiveIntensity: + * emissiveMap: new THREE.Texture( ), + * + * specularMap: new THREE.Texture( ), + * + * alphaMap: new THREE.Texture( ), + * + * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), + * combine: THREE.Multiply, + * reflectivity: , + * refractionRatio: , + * + * wireframe: , + * wireframeLinewidth: , + * + * skinning: , + * morphTargets: , + * morphNormals: + * } + */ + + function MeshLambertMaterial( parameters ) { + + Material.call( this ); + + this.type = 'MeshLambertMaterial'; + + this.color = new Color( 0xffffff ); // diffuse + + this.map = null; + + this.lightMap = null; + this.lightMapIntensity = 1.0; + + this.aoMap = null; + this.aoMapIntensity = 1.0; + + this.emissive = new Color( 0x000000 ); + this.emissiveIntensity = 1.0; + this.emissiveMap = null; + + this.specularMap = null; + + this.alphaMap = null; + + this.envMap = null; + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = 'round'; + this.wireframeLinejoin = 'round'; + + this.skinning = false; + this.morphTargets = false; + this.morphNormals = false; + + this.setValues( parameters ); + + } + + MeshLambertMaterial.prototype = Object.create( Material.prototype ); + MeshLambertMaterial.prototype.constructor = MeshLambertMaterial; + + MeshLambertMaterial.prototype.isMeshLambertMaterial = true; + + MeshLambertMaterial.prototype.copy = function ( source ) { + + Material.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + + this.map = source.map; + + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + + this.emissive.copy( source.emissive ); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + + this.specularMap = source.specularMap; + + this.alphaMap = source.alphaMap; + + this.envMap = source.envMap; + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + + this.skinning = source.skinning; + this.morphTargets = source.morphTargets; + this.morphNormals = source.morphNormals; + + return this; + + }; + + /** + * @author alteredq / http://alteredqualia.com/ + * + * parameters = { + * color: , + * opacity: , + * + * linewidth: , + * + * scale: , + * dashSize: , + * gapSize: + * } + */ + + function LineDashedMaterial( parameters ) { + + LineBasicMaterial.call( this ); + + this.type = 'LineDashedMaterial'; + + this.scale = 1; + this.dashSize = 3; + this.gapSize = 1; + + this.setValues( parameters ); + + } + + LineDashedMaterial.prototype = Object.create( LineBasicMaterial.prototype ); + LineDashedMaterial.prototype.constructor = LineDashedMaterial; + + LineDashedMaterial.prototype.isLineDashedMaterial = true; + + LineDashedMaterial.prototype.copy = function ( source ) { + + LineBasicMaterial.prototype.copy.call( this, source ); + + this.scale = source.scale; + this.dashSize = source.dashSize; + this.gapSize = source.gapSize; + + return this; + + }; + + + + var Materials = Object.freeze({ + ShadowMaterial: ShadowMaterial, + SpriteMaterial: SpriteMaterial, + RawShaderMaterial: RawShaderMaterial, + ShaderMaterial: ShaderMaterial, + PointsMaterial: PointsMaterial, + MeshPhysicalMaterial: MeshPhysicalMaterial, + MeshStandardMaterial: MeshStandardMaterial, + MeshPhongMaterial: MeshPhongMaterial, + MeshToonMaterial: MeshToonMaterial, + MeshNormalMaterial: MeshNormalMaterial, + MeshLambertMaterial: MeshLambertMaterial, + MeshDepthMaterial: MeshDepthMaterial, + MeshDistanceMaterial: MeshDistanceMaterial, + MeshBasicMaterial: MeshBasicMaterial, + LineDashedMaterial: LineDashedMaterial, + LineBasicMaterial: LineBasicMaterial, + Material: Material + }); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + var Cache = { + + enabled: false, + + files: {}, + + add: function ( key, file ) { + + if ( this.enabled === false ) return; + + // console.log( 'THREE.Cache', 'Adding key:', key ); + + this.files[ key ] = file; + + }, + + get: function ( key ) { + + if ( this.enabled === false ) return; + + // console.log( 'THREE.Cache', 'Checking key:', key ); + + return this.files[ key ]; + + }, + + remove: function ( key ) { + + delete this.files[ key ]; + + }, + + clear: function () { + + this.files = {}; + + } + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function LoadingManager( onLoad, onProgress, onError ) { + + var scope = this; + + var isLoading = false; + var itemsLoaded = 0; + var itemsTotal = 0; + var urlModifier = undefined; + + this.onStart = undefined; + this.onLoad = onLoad; + this.onProgress = onProgress; + this.onError = onError; + + this.itemStart = function ( url ) { + + itemsTotal ++; + + if ( isLoading === false ) { + + if ( scope.onStart !== undefined ) { + + scope.onStart( url, itemsLoaded, itemsTotal ); + + } + + } + + isLoading = true; + + }; + + this.itemEnd = function ( url ) { + + itemsLoaded ++; + + if ( scope.onProgress !== undefined ) { + + scope.onProgress( url, itemsLoaded, itemsTotal ); + + } + + if ( itemsLoaded === itemsTotal ) { + + isLoading = false; + + if ( scope.onLoad !== undefined ) { + + scope.onLoad(); + + } + + } + + }; + + this.itemError = function ( url ) { + + if ( scope.onError !== undefined ) { + + scope.onError( url ); + + } + + }; + + this.resolveURL = function ( url ) { + + if ( urlModifier ) { + + return urlModifier( url ); + + } + + return url; + + }; + + this.setURLModifier = function ( transform ) { + + urlModifier = transform; + return this; + + }; + + } + + var DefaultLoadingManager = new LoadingManager(); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + var loading = {}; + + function FileLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( FileLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + if ( url === undefined ) url = ''; + + if ( this.path !== undefined ) url = this.path + url; + + url = this.manager.resolveURL( url ); + + var scope = this; + + var cached = Cache.get( url ); + + if ( cached !== undefined ) { + + scope.manager.itemStart( url ); + + setTimeout( function () { + + if ( onLoad ) onLoad( cached ); + + scope.manager.itemEnd( url ); + + }, 0 ); + + return cached; + + } + + // Check if request is duplicate + + if ( loading[ url ] !== undefined ) { + + loading[ url ].push( { + + onLoad: onLoad, + onProgress: onProgress, + onError: onError + + } ); + + return; + + } + + // Check for data: URI + var dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/; + var dataUriRegexResult = url.match( dataUriRegex ); + + // Safari can not handle Data URIs through XMLHttpRequest so process manually + if ( dataUriRegexResult ) { + + var mimeType = dataUriRegexResult[ 1 ]; + var isBase64 = !! dataUriRegexResult[ 2 ]; + var data = dataUriRegexResult[ 3 ]; + + data = window.decodeURIComponent( data ); + + if ( isBase64 ) data = window.atob( data ); + + try { + + var response; + var responseType = ( this.responseType || '' ).toLowerCase(); + + switch ( responseType ) { + + case 'arraybuffer': + case 'blob': + + var view = new Uint8Array( data.length ); + + for ( var i = 0; i < data.length; i ++ ) { + + view[ i ] = data.charCodeAt( i ); + + } + + if ( responseType === 'blob' ) { + + response = new Blob( [ view.buffer ], { type: mimeType } ); + + } else { + + response = view.buffer; + + } + + break; + + case 'document': + + var parser = new DOMParser(); + response = parser.parseFromString( data, mimeType ); + + break; + + case 'json': + + response = JSON.parse( data ); + + break; + + default: // 'text' or other + + response = data; + + break; + + } + + // Wait for next browser tick like standard XMLHttpRequest event dispatching does + window.setTimeout( function () { + + if ( onLoad ) onLoad( response ); + + scope.manager.itemEnd( url ); + + }, 0 ); + + } catch ( error ) { + + // Wait for next browser tick like standard XMLHttpRequest event dispatching does + window.setTimeout( function () { + + if ( onError ) onError( error ); + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + }, 0 ); + + } + + } else { + + // Initialise array for duplicate requests + + loading[ url ] = []; + + loading[ url ].push( { + + onLoad: onLoad, + onProgress: onProgress, + onError: onError + + } ); + + var request = new XMLHttpRequest(); + + request.open( 'GET', url, true ); + + request.addEventListener( 'load', function ( event ) { + + var response = this.response; + + Cache.add( url, response ); + + var callbacks = loading[ url ]; + + delete loading[ url ]; + + if ( this.status === 200 ) { + + for ( var i = 0, il = callbacks.length; i < il; i ++ ) { + + var callback = callbacks[ i ]; + if ( callback.onLoad ) callback.onLoad( response ); + + } + + scope.manager.itemEnd( url ); + + } else if ( this.status === 0 ) { + + // Some browsers return HTTP Status 0 when using non-http protocol + // e.g. 'file://' or 'data://'. Handle as success. + + console.warn( 'THREE.FileLoader: HTTP Status 0 received.' ); + + for ( var i = 0, il = callbacks.length; i < il; i ++ ) { + + var callback = callbacks[ i ]; + if ( callback.onLoad ) callback.onLoad( response ); + + } + + scope.manager.itemEnd( url ); + + } else { + + for ( var i = 0, il = callbacks.length; i < il; i ++ ) { + + var callback = callbacks[ i ]; + if ( callback.onError ) callback.onError( event ); + + } + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + } + + }, false ); + + request.addEventListener( 'progress', function ( event ) { + + var callbacks = loading[ url ]; + + for ( var i = 0, il = callbacks.length; i < il; i ++ ) { + + var callback = callbacks[ i ]; + if ( callback.onProgress ) callback.onProgress( event ); + + } + + }, false ); + + request.addEventListener( 'error', function ( event ) { + + var callbacks = loading[ url ]; + + delete loading[ url ]; + + for ( var i = 0, il = callbacks.length; i < il; i ++ ) { + + var callback = callbacks[ i ]; + if ( callback.onError ) callback.onError( event ); + + } + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + }, false ); + + if ( this.responseType !== undefined ) request.responseType = this.responseType; + if ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials; + + if ( request.overrideMimeType ) request.overrideMimeType( this.mimeType !== undefined ? this.mimeType : 'text/plain' ); + + for ( var header in this.requestHeader ) { + + request.setRequestHeader( header, this.requestHeader[ header ] ); + + } + + request.send( null ); + + } + + scope.manager.itemStart( url ); + + return request; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + }, + + setResponseType: function ( value ) { + + this.responseType = value; + return this; + + }, + + setWithCredentials: function ( value ) { + + this.withCredentials = value; + return this; + + }, + + setMimeType: function ( value ) { + + this.mimeType = value; + return this; + + }, + + setRequestHeader: function ( value ) { + + this.requestHeader = value; + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * + * Abstract Base class to block based textures loader (dds, pvr, ...) + */ + + function CompressedTextureLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + // override in sub classes + this._parser = null; + + } + + Object.assign( CompressedTextureLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var images = []; + + var texture = new CompressedTexture(); + texture.image = images; + + var loader = new FileLoader( this.manager ); + loader.setPath( this.path ); + loader.setResponseType( 'arraybuffer' ); + + function loadTexture( i ) { + + loader.load( url[ i ], function ( buffer ) { + + var texDatas = scope._parser( buffer, true ); + + images[ i ] = { + width: texDatas.width, + height: texDatas.height, + format: texDatas.format, + mipmaps: texDatas.mipmaps + }; + + loaded += 1; + + if ( loaded === 6 ) { + + if ( texDatas.mipmapCount === 1 ) + texture.minFilter = LinearFilter; + + texture.format = texDatas.format; + texture.needsUpdate = true; + + if ( onLoad ) onLoad( texture ); + + } + + }, onProgress, onError ); + + } + + if ( Array.isArray( url ) ) { + + var loaded = 0; + + for ( var i = 0, il = url.length; i < il; ++ i ) { + + loadTexture( i ); + + } + + } else { + + // compressed cubemap texture stored in a single DDS file + + loader.load( url, function ( buffer ) { + + var texDatas = scope._parser( buffer, true ); + + if ( texDatas.isCubemap ) { + + var faces = texDatas.mipmaps.length / texDatas.mipmapCount; + + for ( var f = 0; f < faces; f ++ ) { + + images[ f ] = { mipmaps: [] }; + + for ( var i = 0; i < texDatas.mipmapCount; i ++ ) { + + images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] ); + images[ f ].format = texDatas.format; + images[ f ].width = texDatas.width; + images[ f ].height = texDatas.height; + + } + + } + + } else { + + texture.image.width = texDatas.width; + texture.image.height = texDatas.height; + texture.mipmaps = texDatas.mipmaps; + + } + + if ( texDatas.mipmapCount === 1 ) { + + texture.minFilter = LinearFilter; + + } + + texture.format = texDatas.format; + texture.needsUpdate = true; + + if ( onLoad ) onLoad( texture ); + + }, onProgress, onError ); + + } + + return texture; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + } ); + + /** + * @author Nikos M. / https://github.com/foo123/ + * + * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...) + */ + + function DataTextureLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + // override in sub classes + this._parser = null; + + } + + Object.assign( DataTextureLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var texture = new DataTexture(); + + var loader = new FileLoader( this.manager ); + loader.setResponseType( 'arraybuffer' ); + + loader.load( url, function ( buffer ) { + + var texData = scope._parser( buffer ); + + if ( ! texData ) return; + + if ( undefined !== texData.image ) { + + texture.image = texData.image; + + } else if ( undefined !== texData.data ) { + + texture.image.width = texData.width; + texture.image.height = texData.height; + texture.image.data = texData.data; + + } + + texture.wrapS = undefined !== texData.wrapS ? texData.wrapS : ClampToEdgeWrapping; + texture.wrapT = undefined !== texData.wrapT ? texData.wrapT : ClampToEdgeWrapping; + + texture.magFilter = undefined !== texData.magFilter ? texData.magFilter : LinearFilter; + texture.minFilter = undefined !== texData.minFilter ? texData.minFilter : LinearMipMapLinearFilter; + + texture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1; + + if ( undefined !== texData.format ) { + + texture.format = texData.format; + + } + if ( undefined !== texData.type ) { + + texture.type = texData.type; + + } + + if ( undefined !== texData.mipmaps ) { + + texture.mipmaps = texData.mipmaps; + + } + + if ( 1 === texData.mipmapCount ) { + + texture.minFilter = LinearFilter; + + } + + texture.needsUpdate = true; + + if ( onLoad ) onLoad( texture, texData ); + + }, onProgress, onError ); + + + return texture; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function ImageLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( ImageLoader.prototype, { + + crossOrigin: 'Anonymous', + + load: function ( url, onLoad, onProgress, onError ) { + + if ( url === undefined ) url = ''; + + if ( this.path !== undefined ) url = this.path + url; + + url = this.manager.resolveURL( url ); + + var scope = this; + + var cached = Cache.get( url ); + + if ( cached !== undefined ) { + + scope.manager.itemStart( url ); + + setTimeout( function () { + + if ( onLoad ) onLoad( cached ); + + scope.manager.itemEnd( url ); + + }, 0 ); + + return cached; + + } + + var image = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'img' ); + + image.addEventListener( 'load', function () { + + Cache.add( url, this ); + + if ( onLoad ) onLoad( this ); + + scope.manager.itemEnd( url ); + + }, false ); + + /* + image.addEventListener( 'progress', function ( event ) { + + if ( onProgress ) onProgress( event ); + + }, false ); + */ + + image.addEventListener( 'error', function ( event ) { + + if ( onError ) onError( event ); + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + }, false ); + + if ( url.substr( 0, 5 ) !== 'data:' ) { + + if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin; + + } + + scope.manager.itemStart( url ); + + image.src = url; + + return image; + + }, + + setCrossOrigin: function ( value ) { + + this.crossOrigin = value; + return this; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function CubeTextureLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( CubeTextureLoader.prototype, { + + crossOrigin: 'Anonymous', + + load: function ( urls, onLoad, onProgress, onError ) { + + var texture = new CubeTexture(); + + var loader = new ImageLoader( this.manager ); + loader.setCrossOrigin( this.crossOrigin ); + loader.setPath( this.path ); + + var loaded = 0; + + function loadTexture( i ) { + + loader.load( urls[ i ], function ( image ) { + + texture.images[ i ] = image; + + loaded ++; + + if ( loaded === 6 ) { + + texture.needsUpdate = true; + + if ( onLoad ) onLoad( texture ); + + } + + }, undefined, onError ); + + } + + for ( var i = 0; i < urls.length; ++ i ) { + + loadTexture( i ); + + } + + return texture; + + }, + + setCrossOrigin: function ( value ) { + + this.crossOrigin = value; + return this; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function TextureLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( TextureLoader.prototype, { + + crossOrigin: 'Anonymous', + + load: function ( url, onLoad, onProgress, onError ) { + + var texture = new Texture(); + + var loader = new ImageLoader( this.manager ); + loader.setCrossOrigin( this.crossOrigin ); + loader.setPath( this.path ); + + loader.load( url, function ( image ) { + + texture.image = image; + + // JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB. + var isJPEG = url.search( /\.(jpg|jpeg)$/ ) > 0 || url.search( /^data\:image\/jpeg/ ) === 0; + + texture.format = isJPEG ? RGBFormat : RGBAFormat; + texture.needsUpdate = true; + + if ( onLoad !== undefined ) { + + onLoad( texture ); + + } + + }, onProgress, onError ); + + return texture; + + }, + + setCrossOrigin: function ( value ) { + + this.crossOrigin = value; + return this; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + } ); + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * Extensible curve object + * + * Some common of curve methods: + * .getPoint( t, optionalTarget ), .getTangent( t ) + * .getPointAt( u, optionalTarget ), .getTangentAt( u ) + * .getPoints(), .getSpacedPoints() + * .getLength() + * .updateArcLengths() + * + * This following curves inherit from THREE.Curve: + * + * -- 2D curves -- + * THREE.ArcCurve + * THREE.CubicBezierCurve + * THREE.EllipseCurve + * THREE.LineCurve + * THREE.QuadraticBezierCurve + * THREE.SplineCurve + * + * -- 3D curves -- + * THREE.CatmullRomCurve3 + * THREE.CubicBezierCurve3 + * THREE.LineCurve3 + * THREE.QuadraticBezierCurve3 + * + * A series of curves can be represented as a THREE.CurvePath. + * + **/ + + /************************************************************** + * Abstract Curve base class + **************************************************************/ + + function Curve() { + + this.type = 'Curve'; + + this.arcLengthDivisions = 200; + + } + + Object.assign( Curve.prototype, { + + // Virtual base class method to overwrite and implement in subclasses + // - t [0 .. 1] + + getPoint: function ( /* t, optionalTarget */ ) { + + console.warn( 'THREE.Curve: .getPoint() not implemented.' ); + return null; + + }, + + // Get point at relative position in curve according to arc length + // - u [0 .. 1] + + getPointAt: function ( u, optionalTarget ) { + + var t = this.getUtoTmapping( u ); + return this.getPoint( t, optionalTarget ); + + }, + + // Get sequence of points using getPoint( t ) + + getPoints: function ( divisions ) { + + if ( divisions === undefined ) divisions = 5; + + var points = []; + + for ( var d = 0; d <= divisions; d ++ ) { + + points.push( this.getPoint( d / divisions ) ); + + } + + return points; + + }, + + // Get sequence of points using getPointAt( u ) + + getSpacedPoints: function ( divisions ) { + + if ( divisions === undefined ) divisions = 5; + + var points = []; + + for ( var d = 0; d <= divisions; d ++ ) { + + points.push( this.getPointAt( d / divisions ) ); + + } + + return points; + + }, + + // Get total curve arc length + + getLength: function () { + + var lengths = this.getLengths(); + return lengths[ lengths.length - 1 ]; + + }, + + // Get list of cumulative segment lengths + + getLengths: function ( divisions ) { + + if ( divisions === undefined ) divisions = this.arcLengthDivisions; + + if ( this.cacheArcLengths && + ( this.cacheArcLengths.length === divisions + 1 ) && + ! this.needsUpdate ) { + + return this.cacheArcLengths; + + } + + this.needsUpdate = false; + + var cache = []; + var current, last = this.getPoint( 0 ); + var p, sum = 0; + + cache.push( 0 ); + + for ( p = 1; p <= divisions; p ++ ) { + + current = this.getPoint( p / divisions ); + sum += current.distanceTo( last ); + cache.push( sum ); + last = current; + + } + + this.cacheArcLengths = cache; + + return cache; // { sums: cache, sum: sum }; Sum is in the last element. + + }, + + updateArcLengths: function () { + + this.needsUpdate = true; + this.getLengths(); + + }, + + // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant + + getUtoTmapping: function ( u, distance ) { + + var arcLengths = this.getLengths(); + + var i = 0, il = arcLengths.length; + + var targetArcLength; // The targeted u distance value to get + + if ( distance ) { + + targetArcLength = distance; + + } else { + + targetArcLength = u * arcLengths[ il - 1 ]; + + } + + // binary search for the index with largest value smaller than target u distance + + var low = 0, high = il - 1, comparison; + + while ( low <= high ) { + + i = 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 + + comparison = arcLengths[ i ] - targetArcLength; + + if ( comparison < 0 ) { + + low = i + 1; + + } else if ( comparison > 0 ) { + + high = i - 1; + + } else { + + high = i; + break; + + // DONE + + } + + } + + i = high; + + if ( arcLengths[ i ] === targetArcLength ) { + + return i / ( il - 1 ); + + } + + // we could get finer grain at lengths, or use simple interpolation between two points + + var lengthBefore = arcLengths[ i ]; + var lengthAfter = arcLengths[ i + 1 ]; + + var segmentLength = lengthAfter - lengthBefore; + + // determine where we are between the 'before' and 'after' points + + var segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength; + + // add that fractional amount to t + + var t = ( i + segmentFraction ) / ( il - 1 ); + + return t; + + }, + + // Returns a unit vector tangent at t + // In case any sub curve does not implement its tangent derivation, + // 2 points a small delta apart will be used to find its gradient + // which seems to give a reasonable approximation + + getTangent: function ( t ) { + + var delta = 0.0001; + var t1 = t - delta; + var t2 = t + delta; + + // Capping in case of danger + + if ( t1 < 0 ) t1 = 0; + if ( t2 > 1 ) t2 = 1; + + var pt1 = this.getPoint( t1 ); + var pt2 = this.getPoint( t2 ); + + var vec = pt2.clone().sub( pt1 ); + return vec.normalize(); + + }, + + getTangentAt: function ( u ) { + + var t = this.getUtoTmapping( u ); + return this.getTangent( t ); + + }, + + computeFrenetFrames: function ( segments, closed ) { + + // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf + + var normal = new Vector3(); + + var tangents = []; + var normals = []; + var binormals = []; + + var vec = new Vector3(); + var mat = new Matrix4(); + + var i, u, theta; + + // compute the tangent vectors for each segment on the curve + + for ( i = 0; i <= segments; i ++ ) { + + u = i / segments; + + tangents[ i ] = this.getTangentAt( u ); + tangents[ i ].normalize(); + + } + + // select an initial normal vector perpendicular to the first tangent vector, + // and in the direction of the minimum tangent xyz component + + normals[ 0 ] = new Vector3(); + binormals[ 0 ] = new Vector3(); + var min = Number.MAX_VALUE; + var tx = Math.abs( tangents[ 0 ].x ); + var ty = Math.abs( tangents[ 0 ].y ); + var tz = Math.abs( tangents[ 0 ].z ); + + if ( tx <= min ) { + + min = tx; + normal.set( 1, 0, 0 ); + + } + + if ( ty <= min ) { + + min = ty; + normal.set( 0, 1, 0 ); + + } + + if ( tz <= min ) { + + normal.set( 0, 0, 1 ); + + } + + vec.crossVectors( tangents[ 0 ], normal ).normalize(); + + normals[ 0 ].crossVectors( tangents[ 0 ], vec ); + binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] ); + + + // compute the slowly-varying normal and binormal vectors for each segment on the curve + + for ( i = 1; i <= segments; i ++ ) { + + normals[ i ] = normals[ i - 1 ].clone(); + + binormals[ i ] = binormals[ i - 1 ].clone(); + + vec.crossVectors( tangents[ i - 1 ], tangents[ i ] ); + + if ( vec.length() > Number.EPSILON ) { + + vec.normalize(); + + theta = Math.acos( _Math.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors + + normals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) ); + + } + + binormals[ i ].crossVectors( tangents[ i ], normals[ i ] ); + + } + + // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same + + if ( closed === true ) { + + theta = Math.acos( _Math.clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) ); + theta /= segments; + + if ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) { + + theta = - theta; + + } + + for ( i = 1; i <= segments; i ++ ) { + + // twist a little... + normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) ); + binormals[ i ].crossVectors( tangents[ i ], normals[ i ] ); + + } + + } + + return { + tangents: tangents, + normals: normals, + binormals: binormals + }; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( source ) { + + this.arcLengthDivisions = source.arcLengthDivisions; + + return this; + + }, + + toJSON: function () { + + var data = { + metadata: { + version: 4.5, + type: 'Curve', + generator: 'Curve.toJSON' + } + }; + + data.arcLengthDivisions = this.arcLengthDivisions; + data.type = this.type; + + return data; + + }, + + fromJSON: function ( json ) { + + this.arcLengthDivisions = json.arcLengthDivisions; + + return this; + + } + + } ); + + function EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) { + + Curve.call( this ); + + this.type = 'EllipseCurve'; + + this.aX = aX || 0; + this.aY = aY || 0; + + this.xRadius = xRadius || 1; + this.yRadius = yRadius || 1; + + this.aStartAngle = aStartAngle || 0; + this.aEndAngle = aEndAngle || 2 * Math.PI; + + this.aClockwise = aClockwise || false; + + this.aRotation = aRotation || 0; + + } + + EllipseCurve.prototype = Object.create( Curve.prototype ); + EllipseCurve.prototype.constructor = EllipseCurve; + + EllipseCurve.prototype.isEllipseCurve = true; + + EllipseCurve.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector2(); + + var twoPi = Math.PI * 2; + var deltaAngle = this.aEndAngle - this.aStartAngle; + var samePoints = Math.abs( deltaAngle ) < Number.EPSILON; + + // ensures that deltaAngle is 0 .. 2 PI + while ( deltaAngle < 0 ) deltaAngle += twoPi; + while ( deltaAngle > twoPi ) deltaAngle -= twoPi; + + if ( deltaAngle < Number.EPSILON ) { + + if ( samePoints ) { + + deltaAngle = 0; + + } else { + + deltaAngle = twoPi; + + } + + } + + if ( this.aClockwise === true && ! samePoints ) { + + if ( deltaAngle === twoPi ) { + + deltaAngle = - twoPi; + + } else { + + deltaAngle = deltaAngle - twoPi; + + } + + } + + var angle = this.aStartAngle + t * deltaAngle; + var x = this.aX + this.xRadius * Math.cos( angle ); + var y = this.aY + this.yRadius * Math.sin( angle ); + + if ( this.aRotation !== 0 ) { + + var cos = Math.cos( this.aRotation ); + var sin = Math.sin( this.aRotation ); + + var tx = x - this.aX; + var ty = y - this.aY; + + // Rotate the point about the center of the ellipse. + x = tx * cos - ty * sin + this.aX; + y = tx * sin + ty * cos + this.aY; + + } + + return point.set( x, y ); + + }; + + EllipseCurve.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.aX = source.aX; + this.aY = source.aY; + + this.xRadius = source.xRadius; + this.yRadius = source.yRadius; + + this.aStartAngle = source.aStartAngle; + this.aEndAngle = source.aEndAngle; + + this.aClockwise = source.aClockwise; + + this.aRotation = source.aRotation; + + return this; + + }; + + + EllipseCurve.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.aX = this.aX; + data.aY = this.aY; + + data.xRadius = this.xRadius; + data.yRadius = this.yRadius; + + data.aStartAngle = this.aStartAngle; + data.aEndAngle = this.aEndAngle; + + data.aClockwise = this.aClockwise; + + data.aRotation = this.aRotation; + + return data; + + }; + + EllipseCurve.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.aX = json.aX; + this.aY = json.aY; + + this.xRadius = json.xRadius; + this.yRadius = json.yRadius; + + this.aStartAngle = json.aStartAngle; + this.aEndAngle = json.aEndAngle; + + this.aClockwise = json.aClockwise; + + this.aRotation = json.aRotation; + + return this; + + }; + + function ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) { + + EllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise ); + + this.type = 'ArcCurve'; + + } + + ArcCurve.prototype = Object.create( EllipseCurve.prototype ); + ArcCurve.prototype.constructor = ArcCurve; + + ArcCurve.prototype.isArcCurve = true; + + /** + * @author zz85 https://github.com/zz85 + * + * Centripetal CatmullRom Curve - which is useful for avoiding + * cusps and self-intersections in non-uniform catmull rom curves. + * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf + * + * curve.type accepts centripetal(default), chordal and catmullrom + * curve.tension is used for catmullrom which defaults to 0.5 + */ + + + /* + Based on an optimized c++ solution in + - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/ + - http://ideone.com/NoEbVM + + This CubicPoly class could be used for reusing some variables and calculations, + but for three.js curve use, it could be possible inlined and flatten into a single function call + which can be placed in CurveUtils. + */ + + function CubicPoly() { + + var c0 = 0, c1 = 0, c2 = 0, c3 = 0; + + /* + * Compute coefficients for a cubic polynomial + * p(s) = c0 + c1*s + c2*s^2 + c3*s^3 + * such that + * p(0) = x0, p(1) = x1 + * and + * p'(0) = t0, p'(1) = t1. + */ + function init( x0, x1, t0, t1 ) { + + c0 = x0; + c1 = t0; + c2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1; + c3 = 2 * x0 - 2 * x1 + t0 + t1; + + } + + return { + + initCatmullRom: function ( x0, x1, x2, x3, tension ) { + + init( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) ); + + }, + + initNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) { + + // compute tangents when parameterized in [t1,t2] + var t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1; + var t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2; + + // rescale tangents for parametrization in [0,1] + t1 *= dt1; + t2 *= dt1; + + init( x1, x2, t1, t2 ); + + }, + + calc: function ( t ) { + + var t2 = t * t; + var t3 = t2 * t; + return c0 + c1 * t + c2 * t2 + c3 * t3; + + } + + }; + + } + + // + + var tmp = new Vector3(); + var px = new CubicPoly(); + var py = new CubicPoly(); + var pz = new CubicPoly(); + + function CatmullRomCurve3( points, closed, curveType, tension ) { + + Curve.call( this ); + + this.type = 'CatmullRomCurve3'; + + this.points = points || []; + this.closed = closed || false; + this.curveType = curveType || 'centripetal'; + this.tension = tension || 0.5; + + } + + CatmullRomCurve3.prototype = Object.create( Curve.prototype ); + CatmullRomCurve3.prototype.constructor = CatmullRomCurve3; + + CatmullRomCurve3.prototype.isCatmullRomCurve3 = true; + + CatmullRomCurve3.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector3(); + + var points = this.points; + var l = points.length; + + var p = ( l - ( this.closed ? 0 : 1 ) ) * t; + var intPoint = Math.floor( p ); + var weight = p - intPoint; + + if ( this.closed ) { + + intPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / points.length ) + 1 ) * points.length; + + } else if ( weight === 0 && intPoint === l - 1 ) { + + intPoint = l - 2; + weight = 1; + + } + + var p0, p1, p2, p3; // 4 points + + if ( this.closed || intPoint > 0 ) { + + p0 = points[ ( intPoint - 1 ) % l ]; + + } else { + + // extrapolate first point + tmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] ); + p0 = tmp; + + } + + p1 = points[ intPoint % l ]; + p2 = points[ ( intPoint + 1 ) % l ]; + + if ( this.closed || intPoint + 2 < l ) { + + p3 = points[ ( intPoint + 2 ) % l ]; + + } else { + + // extrapolate last point + tmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] ); + p3 = tmp; + + } + + if ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) { + + // init Centripetal / Chordal Catmull-Rom + var pow = this.curveType === 'chordal' ? 0.5 : 0.25; + var dt0 = Math.pow( p0.distanceToSquared( p1 ), pow ); + var dt1 = Math.pow( p1.distanceToSquared( p2 ), pow ); + var dt2 = Math.pow( p2.distanceToSquared( p3 ), pow ); + + // safety check for repeated points + if ( dt1 < 1e-4 ) dt1 = 1.0; + if ( dt0 < 1e-4 ) dt0 = dt1; + if ( dt2 < 1e-4 ) dt2 = dt1; + + px.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 ); + py.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 ); + pz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 ); + + } else if ( this.curveType === 'catmullrom' ) { + + px.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension ); + py.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension ); + pz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension ); + + } + + point.set( + px.calc( weight ), + py.calc( weight ), + pz.calc( weight ) + ); + + return point; + + }; + + CatmullRomCurve3.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.points = []; + + for ( var i = 0, l = source.points.length; i < l; i ++ ) { + + var point = source.points[ i ]; + + this.points.push( point.clone() ); + + } + + this.closed = source.closed; + this.curveType = source.curveType; + this.tension = source.tension; + + return this; + + }; + + CatmullRomCurve3.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.points = []; + + for ( var i = 0, l = this.points.length; i < l; i ++ ) { + + var point = this.points[ i ]; + data.points.push( point.toArray() ); + + } + + data.closed = this.closed; + data.curveType = this.curveType; + data.tension = this.tension; + + return data; + + }; + + CatmullRomCurve3.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.points = []; + + for ( var i = 0, l = json.points.length; i < l; i ++ ) { + + var point = json.points[ i ]; + this.points.push( new Vector3().fromArray( point ) ); + + } + + this.closed = json.closed; + this.curveType = json.curveType; + this.tension = json.tension; + + return this; + + }; + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * + * Bezier Curves formulas obtained from + * http://en.wikipedia.org/wiki/Bézier_curve + */ + + function CatmullRom( t, p0, p1, p2, p3 ) { + + var v0 = ( p2 - p0 ) * 0.5; + var v1 = ( p3 - p1 ) * 0.5; + var t2 = t * t; + var t3 = t * t2; + return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1; + + } + + // + + function QuadraticBezierP0( t, p ) { + + var k = 1 - t; + return k * k * p; + + } + + function QuadraticBezierP1( t, p ) { + + return 2 * ( 1 - t ) * t * p; + + } + + function QuadraticBezierP2( t, p ) { + + return t * t * p; + + } + + function QuadraticBezier( t, p0, p1, p2 ) { + + return QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) + + QuadraticBezierP2( t, p2 ); + + } + + // + + function CubicBezierP0( t, p ) { + + var k = 1 - t; + return k * k * k * p; + + } + + function CubicBezierP1( t, p ) { + + var k = 1 - t; + return 3 * k * k * t * p; + + } + + function CubicBezierP2( t, p ) { + + return 3 * ( 1 - t ) * t * t * p; + + } + + function CubicBezierP3( t, p ) { + + return t * t * t * p; + + } + + function CubicBezier( t, p0, p1, p2, p3 ) { + + return CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) + + CubicBezierP3( t, p3 ); + + } + + function CubicBezierCurve( v0, v1, v2, v3 ) { + + Curve.call( this ); + + this.type = 'CubicBezierCurve'; + + this.v0 = v0 || new Vector2(); + this.v1 = v1 || new Vector2(); + this.v2 = v2 || new Vector2(); + this.v3 = v3 || new Vector2(); + + } + + CubicBezierCurve.prototype = Object.create( Curve.prototype ); + CubicBezierCurve.prototype.constructor = CubicBezierCurve; + + CubicBezierCurve.prototype.isCubicBezierCurve = true; + + CubicBezierCurve.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector2(); + + var v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3; + + point.set( + CubicBezier( t, v0.x, v1.x, v2.x, v3.x ), + CubicBezier( t, v0.y, v1.y, v2.y, v3.y ) + ); + + return point; + + }; + + CubicBezierCurve.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v0.copy( source.v0 ); + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + this.v3.copy( source.v3 ); + + return this; + + }; + + CubicBezierCurve.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v0 = this.v0.toArray(); + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + data.v3 = this.v3.toArray(); + + return data; + + }; + + CubicBezierCurve.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v0.fromArray( json.v0 ); + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + this.v3.fromArray( json.v3 ); + + return this; + + }; + + function CubicBezierCurve3( v0, v1, v2, v3 ) { + + Curve.call( this ); + + this.type = 'CubicBezierCurve3'; + + this.v0 = v0 || new Vector3(); + this.v1 = v1 || new Vector3(); + this.v2 = v2 || new Vector3(); + this.v3 = v3 || new Vector3(); + + } + + CubicBezierCurve3.prototype = Object.create( Curve.prototype ); + CubicBezierCurve3.prototype.constructor = CubicBezierCurve3; + + CubicBezierCurve3.prototype.isCubicBezierCurve3 = true; + + CubicBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector3(); + + var v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3; + + point.set( + CubicBezier( t, v0.x, v1.x, v2.x, v3.x ), + CubicBezier( t, v0.y, v1.y, v2.y, v3.y ), + CubicBezier( t, v0.z, v1.z, v2.z, v3.z ) + ); + + return point; + + }; + + CubicBezierCurve3.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v0.copy( source.v0 ); + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + this.v3.copy( source.v3 ); + + return this; + + }; + + CubicBezierCurve3.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v0 = this.v0.toArray(); + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + data.v3 = this.v3.toArray(); + + return data; + + }; + + CubicBezierCurve3.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v0.fromArray( json.v0 ); + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + this.v3.fromArray( json.v3 ); + + return this; + + }; + + function LineCurve( v1, v2 ) { + + Curve.call( this ); + + this.type = 'LineCurve'; + + this.v1 = v1 || new Vector2(); + this.v2 = v2 || new Vector2(); + + } + + LineCurve.prototype = Object.create( Curve.prototype ); + LineCurve.prototype.constructor = LineCurve; + + LineCurve.prototype.isLineCurve = true; + + LineCurve.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector2(); + + if ( t === 1 ) { + + point.copy( this.v2 ); + + } else { + + point.copy( this.v2 ).sub( this.v1 ); + point.multiplyScalar( t ).add( this.v1 ); + + } + + return point; + + }; + + // Line curve is linear, so we can overwrite default getPointAt + + LineCurve.prototype.getPointAt = function ( u, optionalTarget ) { + + return this.getPoint( u, optionalTarget ); + + }; + + LineCurve.prototype.getTangent = function ( /* t */ ) { + + var tangent = this.v2.clone().sub( this.v1 ); + + return tangent.normalize(); + + }; + + LineCurve.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + + return this; + + }; + + LineCurve.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + + return data; + + }; + + LineCurve.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + + return this; + + }; + + function LineCurve3( v1, v2 ) { + + Curve.call( this ); + + this.type = 'LineCurve3'; + + this.v1 = v1 || new Vector3(); + this.v2 = v2 || new Vector3(); + + } + + LineCurve3.prototype = Object.create( Curve.prototype ); + LineCurve3.prototype.constructor = LineCurve3; + + LineCurve3.prototype.isLineCurve3 = true; + + LineCurve3.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector3(); + + if ( t === 1 ) { + + point.copy( this.v2 ); + + } else { + + point.copy( this.v2 ).sub( this.v1 ); + point.multiplyScalar( t ).add( this.v1 ); + + } + + return point; + + }; + + // Line curve is linear, so we can overwrite default getPointAt + + LineCurve3.prototype.getPointAt = function ( u, optionalTarget ) { + + return this.getPoint( u, optionalTarget ); + + }; + + LineCurve3.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + + return this; + + }; + + LineCurve3.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + + return data; + + }; + + LineCurve3.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + + return this; + + }; + + function QuadraticBezierCurve( v0, v1, v2 ) { + + Curve.call( this ); + + this.type = 'QuadraticBezierCurve'; + + this.v0 = v0 || new Vector2(); + this.v1 = v1 || new Vector2(); + this.v2 = v2 || new Vector2(); + + } + + QuadraticBezierCurve.prototype = Object.create( Curve.prototype ); + QuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve; + + QuadraticBezierCurve.prototype.isQuadraticBezierCurve = true; + + QuadraticBezierCurve.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector2(); + + var v0 = this.v0, v1 = this.v1, v2 = this.v2; + + point.set( + QuadraticBezier( t, v0.x, v1.x, v2.x ), + QuadraticBezier( t, v0.y, v1.y, v2.y ) + ); + + return point; + + }; + + QuadraticBezierCurve.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v0.copy( source.v0 ); + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + + return this; + + }; + + QuadraticBezierCurve.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v0 = this.v0.toArray(); + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + + return data; + + }; + + QuadraticBezierCurve.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v0.fromArray( json.v0 ); + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + + return this; + + }; + + function QuadraticBezierCurve3( v0, v1, v2 ) { + + Curve.call( this ); + + this.type = 'QuadraticBezierCurve3'; + + this.v0 = v0 || new Vector3(); + this.v1 = v1 || new Vector3(); + this.v2 = v2 || new Vector3(); + + } + + QuadraticBezierCurve3.prototype = Object.create( Curve.prototype ); + QuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3; + + QuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true; + + QuadraticBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector3(); + + var v0 = this.v0, v1 = this.v1, v2 = this.v2; + + point.set( + QuadraticBezier( t, v0.x, v1.x, v2.x ), + QuadraticBezier( t, v0.y, v1.y, v2.y ), + QuadraticBezier( t, v0.z, v1.z, v2.z ) + ); + + return point; + + }; + + QuadraticBezierCurve3.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.v0.copy( source.v0 ); + this.v1.copy( source.v1 ); + this.v2.copy( source.v2 ); + + return this; + + }; + + QuadraticBezierCurve3.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.v0 = this.v0.toArray(); + data.v1 = this.v1.toArray(); + data.v2 = this.v2.toArray(); + + return data; + + }; + + QuadraticBezierCurve3.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.v0.fromArray( json.v0 ); + this.v1.fromArray( json.v1 ); + this.v2.fromArray( json.v2 ); + + return this; + + }; + + function SplineCurve( points /* array of Vector2 */ ) { + + Curve.call( this ); + + this.type = 'SplineCurve'; + + this.points = points || []; + + } + + SplineCurve.prototype = Object.create( Curve.prototype ); + SplineCurve.prototype.constructor = SplineCurve; + + SplineCurve.prototype.isSplineCurve = true; + + SplineCurve.prototype.getPoint = function ( t, optionalTarget ) { + + var point = optionalTarget || new Vector2(); + + var points = this.points; + var p = ( points.length - 1 ) * t; + + var intPoint = Math.floor( p ); + var weight = p - intPoint; + + var p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ]; + var p1 = points[ intPoint ]; + var p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ]; + var p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ]; + + point.set( + CatmullRom( weight, p0.x, p1.x, p2.x, p3.x ), + CatmullRom( weight, p0.y, p1.y, p2.y, p3.y ) + ); + + return point; + + }; + + SplineCurve.prototype.copy = function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.points = []; + + for ( var i = 0, l = source.points.length; i < l; i ++ ) { + + var point = source.points[ i ]; + + this.points.push( point.clone() ); + + } + + return this; + + }; + + SplineCurve.prototype.toJSON = function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.points = []; + + for ( var i = 0, l = this.points.length; i < l; i ++ ) { + + var point = this.points[ i ]; + data.points.push( point.toArray() ); + + } + + return data; + + }; + + SplineCurve.prototype.fromJSON = function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.points = []; + + for ( var i = 0, l = json.points.length; i < l; i ++ ) { + + var point = json.points[ i ]; + this.points.push( new Vector2().fromArray( point ) ); + + } + + return this; + + }; + + + + var Curves = Object.freeze({ + ArcCurve: ArcCurve, + CatmullRomCurve3: CatmullRomCurve3, + CubicBezierCurve: CubicBezierCurve, + CubicBezierCurve3: CubicBezierCurve3, + EllipseCurve: EllipseCurve, + LineCurve: LineCurve, + LineCurve3: LineCurve3, + QuadraticBezierCurve: QuadraticBezierCurve, + QuadraticBezierCurve3: QuadraticBezierCurve3, + SplineCurve: SplineCurve + }); + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * + **/ + + /************************************************************** + * Curved Path - a curve path is simply a array of connected + * curves, but retains the api of a curve + **************************************************************/ + + function CurvePath() { + + Curve.call( this ); + + this.type = 'CurvePath'; + + this.curves = []; + this.autoClose = false; // Automatically closes the path + + } + + CurvePath.prototype = Object.assign( Object.create( Curve.prototype ), { + + constructor: CurvePath, + + add: function ( curve ) { + + this.curves.push( curve ); + + }, + + closePath: function () { + + // Add a line curve if start and end of lines are not connected + var startPoint = this.curves[ 0 ].getPoint( 0 ); + var endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 ); + + if ( ! startPoint.equals( endPoint ) ) { + + this.curves.push( new LineCurve( endPoint, startPoint ) ); + + } + + }, + + // To get accurate point with reference to + // entire path distance at time t, + // following has to be done: + + // 1. Length of each sub path have to be known + // 2. Locate and identify type of curve + // 3. Get t for the curve + // 4. Return curve.getPointAt(t') + + getPoint: function ( t ) { + + var d = t * this.getLength(); + var curveLengths = this.getCurveLengths(); + var i = 0; + + // To think about boundaries points. + + while ( i < curveLengths.length ) { + + if ( curveLengths[ i ] >= d ) { + + var diff = curveLengths[ i ] - d; + var curve = this.curves[ i ]; + + var segmentLength = curve.getLength(); + var u = segmentLength === 0 ? 0 : 1 - diff / segmentLength; + + return curve.getPointAt( u ); + + } + + i ++; + + } + + return null; + + // loop where sum != 0, sum > d , sum+1 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) { + + points.push( points[ 0 ] ); + + } + + return points; + + }, + + copy: function ( source ) { + + Curve.prototype.copy.call( this, source ); + + this.curves = []; + + for ( var i = 0, l = source.curves.length; i < l; i ++ ) { + + var curve = source.curves[ i ]; + + this.curves.push( curve.clone() ); + + } + + this.autoClose = source.autoClose; + + return this; + + }, + + toJSON: function () { + + var data = Curve.prototype.toJSON.call( this ); + + data.autoClose = this.autoClose; + data.curves = []; + + for ( var i = 0, l = this.curves.length; i < l; i ++ ) { + + var curve = this.curves[ i ]; + data.curves.push( curve.toJSON() ); + + } + + return data; + + }, + + fromJSON: function ( json ) { + + Curve.prototype.fromJSON.call( this, json ); + + this.autoClose = json.autoClose; + this.curves = []; + + for ( var i = 0, l = json.curves.length; i < l; i ++ ) { + + var curve = json.curves[ i ]; + this.curves.push( new Curves[ curve.type ]().fromJSON( curve ) ); + + } + + return this; + + } + + } ); + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * Creates free form 2d path using series of points, lines or curves. + **/ + + function Path( points ) { + + CurvePath.call( this ); + + this.type = 'Path'; + + this.currentPoint = new Vector2(); + + if ( points ) { + + this.setFromPoints( points ); + + } + + } + + Path.prototype = Object.assign( Object.create( CurvePath.prototype ), { + + constructor: Path, + + setFromPoints: function ( points ) { + + this.moveTo( points[ 0 ].x, points[ 0 ].y ); + + for ( var i = 1, l = points.length; i < l; i ++ ) { + + this.lineTo( points[ i ].x, points[ i ].y ); + + } + + }, + + moveTo: function ( x, y ) { + + this.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying? + + }, + + lineTo: function ( x, y ) { + + var curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) ); + this.curves.push( curve ); + + this.currentPoint.set( x, y ); + + }, + + quadraticCurveTo: function ( aCPx, aCPy, aX, aY ) { + + var curve = new QuadraticBezierCurve( + this.currentPoint.clone(), + new Vector2( aCPx, aCPy ), + new Vector2( aX, aY ) + ); + + this.curves.push( curve ); + + this.currentPoint.set( aX, aY ); + + }, + + bezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) { + + var curve = new CubicBezierCurve( + this.currentPoint.clone(), + new Vector2( aCP1x, aCP1y ), + new Vector2( aCP2x, aCP2y ), + new Vector2( aX, aY ) + ); + + this.curves.push( curve ); + + this.currentPoint.set( aX, aY ); + + }, + + splineThru: function ( pts /*Array of Vector*/ ) { + + var npts = [ this.currentPoint.clone() ].concat( pts ); + + var curve = new SplineCurve( npts ); + this.curves.push( curve ); + + this.currentPoint.copy( pts[ pts.length - 1 ] ); + + }, + + arc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) { + + var x0 = this.currentPoint.x; + var y0 = this.currentPoint.y; + + this.absarc( aX + x0, aY + y0, aRadius, + aStartAngle, aEndAngle, aClockwise ); + + }, + + absarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) { + + this.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise ); + + }, + + ellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) { + + var x0 = this.currentPoint.x; + var y0 = this.currentPoint.y; + + this.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ); + + }, + + absellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) { + + var curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ); + + if ( this.curves.length > 0 ) { + + // if a previous curve is present, attempt to join + var firstPoint = curve.getPoint( 0 ); + + if ( ! firstPoint.equals( this.currentPoint ) ) { + + this.lineTo( firstPoint.x, firstPoint.y ); + + } + + } + + this.curves.push( curve ); + + var lastPoint = curve.getPoint( 1 ); + this.currentPoint.copy( lastPoint ); + + }, + + copy: function ( source ) { + + CurvePath.prototype.copy.call( this, source ); + + this.currentPoint.copy( source.currentPoint ); + + return this; + + }, + + toJSON: function () { + + var data = CurvePath.prototype.toJSON.call( this ); + + data.currentPoint = this.currentPoint.toArray(); + + return data; + + }, + + fromJSON: function ( json ) { + + CurvePath.prototype.fromJSON.call( this, json ); + + this.currentPoint.fromArray( json.currentPoint ); + + return this; + + } + + } ); + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * Defines a 2d shape plane using paths. + **/ + + // STEP 1 Create a path. + // STEP 2 Turn path into shape. + // STEP 3 ExtrudeGeometry takes in Shape/Shapes + // STEP 3a - Extract points from each shape, turn to vertices + // STEP 3b - Triangulate each shape, add faces. + + function Shape( points ) { + + Path.call( this, points ); + + this.uuid = _Math.generateUUID(); + + this.type = 'Shape'; + + this.holes = []; + + } + + Shape.prototype = Object.assign( Object.create( Path.prototype ), { + + constructor: Shape, + + getPointsHoles: function ( divisions ) { + + var holesPts = []; + + for ( var i = 0, l = this.holes.length; i < l; i ++ ) { + + holesPts[ i ] = this.holes[ i ].getPoints( divisions ); + + } + + return holesPts; + + }, + + // get points of shape and holes (keypoints based on segments parameter) + + extractPoints: function ( divisions ) { + + return { + + shape: this.getPoints( divisions ), + holes: this.getPointsHoles( divisions ) + + }; + + }, + + copy: function ( source ) { + + Path.prototype.copy.call( this, source ); + + this.holes = []; + + for ( var i = 0, l = source.holes.length; i < l; i ++ ) { + + var hole = source.holes[ i ]; + + this.holes.push( hole.clone() ); + + } + + return this; + + }, + + toJSON: function () { + + var data = Path.prototype.toJSON.call( this ); + + data.uuid = this.uuid; + data.holes = []; + + for ( var i = 0, l = this.holes.length; i < l; i ++ ) { + + var hole = this.holes[ i ]; + data.holes.push( hole.toJSON() ); + + } + + return data; + + }, + + fromJSON: function ( json ) { + + Path.prototype.fromJSON.call( this, json ); + + this.uuid = json.uuid; + this.holes = []; + + for ( var i = 0, l = json.holes.length; i < l; i ++ ) { + + var hole = json.holes[ i ]; + this.holes.push( new Path().fromJSON( hole ) ); + + } + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function Light( color, intensity ) { + + Object3D.call( this ); + + this.type = 'Light'; + + this.color = new Color( color ); + this.intensity = intensity !== undefined ? intensity : 1; + + this.receiveShadow = undefined; + + } + + Light.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Light, + + isLight: true, + + copy: function ( source ) { + + Object3D.prototype.copy.call( this, source ); + + this.color.copy( source.color ); + this.intensity = source.intensity; + + return this; + + }, + + toJSON: function ( meta ) { + + var data = Object3D.prototype.toJSON.call( this, meta ); + + data.object.color = this.color.getHex(); + data.object.intensity = this.intensity; + + if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex(); + + if ( this.distance !== undefined ) data.object.distance = this.distance; + if ( this.angle !== undefined ) data.object.angle = this.angle; + if ( this.decay !== undefined ) data.object.decay = this.decay; + if ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra; + + if ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON(); + + return data; + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function HemisphereLight( skyColor, groundColor, intensity ) { + + Light.call( this, skyColor, intensity ); + + this.type = 'HemisphereLight'; + + this.castShadow = undefined; + + this.position.copy( Object3D.DefaultUp ); + this.updateMatrix(); + + this.groundColor = new Color( groundColor ); + + } + + HemisphereLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: HemisphereLight, + + isHemisphereLight: true, + + copy: function ( source ) { + + Light.prototype.copy.call( this, source ); + + this.groundColor.copy( source.groundColor ); + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function LightShadow( camera ) { + + this.camera = camera; + + this.bias = 0; + this.radius = 1; + + this.mapSize = new Vector2( 512, 512 ); + + this.map = null; + this.matrix = new Matrix4(); + + } + + Object.assign( LightShadow.prototype, { + + copy: function ( source ) { + + this.camera = source.camera.clone(); + + this.bias = source.bias; + this.radius = source.radius; + + this.mapSize.copy( source.mapSize ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + toJSON: function () { + + var object = {}; + + if ( this.bias !== 0 ) object.bias = this.bias; + if ( this.radius !== 1 ) object.radius = this.radius; + if ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray(); + + object.camera = this.camera.toJSON( false ).object; + delete object.camera.matrix; + + return object; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function SpotLightShadow() { + + LightShadow.call( this, new PerspectiveCamera( 50, 1, 0.5, 500 ) ); + + } + + SpotLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), { + + constructor: SpotLightShadow, + + isSpotLightShadow: true, + + update: function ( light ) { + + var camera = this.camera; + + var fov = _Math.RAD2DEG * 2 * light.angle; + var aspect = this.mapSize.width / this.mapSize.height; + var far = light.distance || camera.far; + + if ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) { + + camera.fov = fov; + camera.aspect = aspect; + camera.far = far; + camera.updateProjectionMatrix(); + + } + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function SpotLight( color, intensity, distance, angle, penumbra, decay ) { + + Light.call( this, color, intensity ); + + this.type = 'SpotLight'; + + this.position.copy( Object3D.DefaultUp ); + this.updateMatrix(); + + this.target = new Object3D(); + + Object.defineProperty( this, 'power', { + get: function () { + + // intensity = power per solid angle. + // ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf + return this.intensity * Math.PI; + + }, + set: function ( power ) { + + // intensity = power per solid angle. + // ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf + this.intensity = power / Math.PI; + + } + } ); + + this.distance = ( distance !== undefined ) ? distance : 0; + this.angle = ( angle !== undefined ) ? angle : Math.PI / 3; + this.penumbra = ( penumbra !== undefined ) ? penumbra : 0; + this.decay = ( decay !== undefined ) ? decay : 1; // for physically correct lights, should be 2. + + this.shadow = new SpotLightShadow(); + + } + + SpotLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: SpotLight, + + isSpotLight: true, + + copy: function ( source ) { + + Light.prototype.copy.call( this, source ); + + this.distance = source.distance; + this.angle = source.angle; + this.penumbra = source.penumbra; + this.decay = source.decay; + + this.target = source.target.clone(); + + this.shadow = source.shadow.clone(); + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + + function PointLight( color, intensity, distance, decay ) { + + Light.call( this, color, intensity ); + + this.type = 'PointLight'; + + Object.defineProperty( this, 'power', { + get: function () { + + // intensity = power per solid angle. + // ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf + return this.intensity * 4 * Math.PI; + + }, + set: function ( power ) { + + // intensity = power per solid angle. + // ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf + this.intensity = power / ( 4 * Math.PI ); + + } + } ); + + this.distance = ( distance !== undefined ) ? distance : 0; + this.decay = ( decay !== undefined ) ? decay : 1; // for physically correct lights, should be 2. + + this.shadow = new LightShadow( new PerspectiveCamera( 90, 1, 0.5, 500 ) ); + + } + + PointLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: PointLight, + + isPointLight: true, + + copy: function ( source ) { + + Light.prototype.copy.call( this, source ); + + this.distance = source.distance; + this.decay = source.decay; + + this.shadow = source.shadow.clone(); + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function DirectionalLightShadow( ) { + + LightShadow.call( this, new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) ); + + } + + DirectionalLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), { + + constructor: DirectionalLightShadow + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function DirectionalLight( color, intensity ) { + + Light.call( this, color, intensity ); + + this.type = 'DirectionalLight'; + + this.position.copy( Object3D.DefaultUp ); + this.updateMatrix(); + + this.target = new Object3D(); + + this.shadow = new DirectionalLightShadow(); + + } + + DirectionalLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: DirectionalLight, + + isDirectionalLight: true, + + copy: function ( source ) { + + Light.prototype.copy.call( this, source ); + + this.target = source.target.clone(); + + this.shadow = source.shadow.clone(); + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function AmbientLight( color, intensity ) { + + Light.call( this, color, intensity ); + + this.type = 'AmbientLight'; + + this.castShadow = undefined; + + } + + AmbientLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: AmbientLight, + + isAmbientLight: true + + } ); + + /** + * @author abelnation / http://github.com/abelnation + */ + + function RectAreaLight( color, intensity, width, height ) { + + Light.call( this, color, intensity ); + + this.type = 'RectAreaLight'; + + this.position.set( 0, 1, 0 ); + this.updateMatrix(); + + this.width = ( width !== undefined ) ? width : 10; + this.height = ( height !== undefined ) ? height : 10; + + // TODO (abelnation): distance/decay + + // TODO (abelnation): update method for RectAreaLight to update transform to lookat target + + // TODO (abelnation): shadows + + } + + // TODO (abelnation): RectAreaLight update when light shape is changed + RectAreaLight.prototype = Object.assign( Object.create( Light.prototype ), { + + constructor: RectAreaLight, + + isRectAreaLight: true, + + copy: function ( source ) { + + Light.prototype.copy.call( this, source ); + + this.width = source.width; + this.height = source.height; + + return this; + + }, + + toJSON: function ( meta ) { + + var data = Light.prototype.toJSON.call( this, meta ); + + data.object.width = this.width; + data.object.height = this.height; + + return data; + + } + + } ); + + /** + * + * A Track that interpolates Strings + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function StringKeyframeTrack( name, times, values, interpolation ) { + + KeyframeTrack.call( this, name, times, values, interpolation ); + + } + + StringKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: StringKeyframeTrack, + + ValueTypeName: 'string', + ValueBufferType: Array, + + DefaultInterpolation: InterpolateDiscrete, + + InterpolantFactoryMethodLinear: undefined, + + InterpolantFactoryMethodSmooth: undefined + + } ); + + /** + * + * A Track of Boolean keyframe values. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function BooleanKeyframeTrack( name, times, values ) { + + KeyframeTrack.call( this, name, times, values ); + + } + + BooleanKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: BooleanKeyframeTrack, + + ValueTypeName: 'bool', + ValueBufferType: Array, + + DefaultInterpolation: InterpolateDiscrete, + + InterpolantFactoryMethodLinear: undefined, + InterpolantFactoryMethodSmooth: undefined + + // Note: Actually this track could have a optimized / compressed + // representation of a single value and a custom interpolant that + // computes "firstValue ^ isOdd( index )". + + } ); + + /** + * Abstract base class of interpolants over parametric samples. + * + * The parameter domain is one dimensional, typically the time or a path + * along a curve defined by the data. + * + * The sample values can have any dimensionality and derived classes may + * apply special interpretations to the data. + * + * This class provides the interval seek in a Template Method, deferring + * the actual interpolation to derived classes. + * + * Time complexity is O(1) for linear access crossing at most two points + * and O(log N) for random access, where N is the number of positions. + * + * References: + * + * http://www.oodesign.com/template-method-pattern.html + * + * @author tschw + */ + + function Interpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + this.parameterPositions = parameterPositions; + this._cachedIndex = 0; + + this.resultBuffer = resultBuffer !== undefined ? + resultBuffer : new sampleValues.constructor( sampleSize ); + this.sampleValues = sampleValues; + this.valueSize = sampleSize; + + } + + Object.assign( Interpolant.prototype, { + + evaluate: function ( t ) { + + var pp = this.parameterPositions, + i1 = this._cachedIndex, + + t1 = pp[ i1 ], + t0 = pp[ i1 - 1 ]; + + validate_interval: { + + seek: { + + var right; + + linear_scan: { + + //- See http://jsperf.com/comparison-to-undefined/3 + //- slower code: + //- + //- if ( t >= t1 || t1 === undefined ) { + forward_scan: if ( ! ( t < t1 ) ) { + + for ( var giveUpAt = i1 + 2; ; ) { + + if ( t1 === undefined ) { + + if ( t < t0 ) break forward_scan; + + // after end + + i1 = pp.length; + this._cachedIndex = i1; + return this.afterEnd_( i1 - 1, t, t0 ); + + } + + if ( i1 === giveUpAt ) break; // this loop + + t0 = t1; + t1 = pp[ ++ i1 ]; + + if ( t < t1 ) { + + // we have arrived at the sought interval + break seek; + + } + + } + + // prepare binary search on the right side of the index + right = pp.length; + break linear_scan; + + } + + //- slower code: + //- if ( t < t0 || t0 === undefined ) { + if ( ! ( t >= t0 ) ) { + + // looping? + + var t1global = pp[ 1 ]; + + if ( t < t1global ) { + + i1 = 2; // + 1, using the scan for the details + t0 = t1global; + + } + + // linear reverse scan + + for ( var giveUpAt = i1 - 2; ; ) { + + if ( t0 === undefined ) { + + // before start + + this._cachedIndex = 0; + return this.beforeStart_( 0, t, t1 ); + + } + + if ( i1 === giveUpAt ) break; // this loop + + t1 = t0; + t0 = pp[ -- i1 - 1 ]; + + if ( t >= t0 ) { + + // we have arrived at the sought interval + break seek; + + } + + } + + // prepare binary search on the left side of the index + right = i1; + i1 = 0; + break linear_scan; + + } + + // the interval is valid + + break validate_interval; + + } // linear scan + + // binary search + + while ( i1 < right ) { + + var mid = ( i1 + right ) >>> 1; + + if ( t < pp[ mid ] ) { + + right = mid; + + } else { + + i1 = mid + 1; + + } + + } + + t1 = pp[ i1 ]; + t0 = pp[ i1 - 1 ]; + + // check boundary cases, again + + if ( t0 === undefined ) { + + this._cachedIndex = 0; + return this.beforeStart_( 0, t, t1 ); + + } + + if ( t1 === undefined ) { + + i1 = pp.length; + this._cachedIndex = i1; + return this.afterEnd_( i1 - 1, t0, t ); + + } + + } // seek + + this._cachedIndex = i1; + + this.intervalChanged_( i1, t0, t1 ); + + } // validate_interval + + return this.interpolate_( i1, t0, t, t1 ); + + }, + + settings: null, // optional, subclass-specific settings structure + // Note: The indirection allows central control of many interpolants. + + // --- Protected interface + + DefaultSettings_: {}, + + getSettings_: function () { + + return this.settings || this.DefaultSettings_; + + }, + + copySampleValue_: function ( index ) { + + // copies a sample value to the result buffer + + var result = this.resultBuffer, + values = this.sampleValues, + stride = this.valueSize, + offset = index * stride; + + for ( var i = 0; i !== stride; ++ i ) { + + result[ i ] = values[ offset + i ]; + + } + + return result; + + }, + + // Template methods for derived classes: + + interpolate_: function ( /* i1, t0, t, t1 */ ) { + + throw new Error( 'call to abstract method' ); + // implementations shall return this.resultBuffer + + }, + + intervalChanged_: function ( /* i1, t0, t1 */ ) { + + // empty + + } + + } ); + + //!\ DECLARE ALIAS AFTER assign prototype ! + Object.assign( Interpolant.prototype, { + + //( 0, t, t0 ), returns this.resultBuffer + beforeStart_: Interpolant.prototype.copySampleValue_, + + //( N-1, tN-1, t ), returns this.resultBuffer + afterEnd_: Interpolant.prototype.copySampleValue_, + + } ); + + /** + * Spherical linear unit quaternion interpolant. + * + * @author tschw + */ + + function QuaternionLinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer ); + + } + + QuaternionLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), { + + constructor: QuaternionLinearInterpolant, + + interpolate_: function ( i1, t0, t, t1 ) { + + var result = this.resultBuffer, + values = this.sampleValues, + stride = this.valueSize, + + offset = i1 * stride, + + alpha = ( t - t0 ) / ( t1 - t0 ); + + for ( var end = offset + stride; offset !== end; offset += 4 ) { + + Quaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha ); + + } + + return result; + + } + + } ); + + /** + * + * A Track of quaternion keyframe values. + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function QuaternionKeyframeTrack( name, times, values, interpolation ) { + + KeyframeTrack.call( this, name, times, values, interpolation ); + + } + + QuaternionKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: QuaternionKeyframeTrack, + + ValueTypeName: 'quaternion', + + // ValueBufferType is inherited + + DefaultInterpolation: InterpolateLinear, + + InterpolantFactoryMethodLinear: function ( result ) { + + return new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result ); + + }, + + InterpolantFactoryMethodSmooth: undefined // not yet implemented + + } ); + + /** + * + * A Track of keyframe values that represent color. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function ColorKeyframeTrack( name, times, values, interpolation ) { + + KeyframeTrack.call( this, name, times, values, interpolation ); + + } + + ColorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: ColorKeyframeTrack, + + ValueTypeName: 'color' + + // ValueBufferType is inherited + + // DefaultInterpolation is inherited + + // Note: Very basic implementation and nothing special yet. + // However, this is the place for color space parameterization. + + } ); + + /** + * + * A Track of numeric keyframe values. + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function NumberKeyframeTrack( name, times, values, interpolation ) { + + KeyframeTrack.call( this, name, times, values, interpolation ); + + } + + NumberKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: NumberKeyframeTrack, + + ValueTypeName: 'number' + + // ValueBufferType is inherited + + // DefaultInterpolation is inherited + + } ); + + /** + * Fast and simple cubic spline interpolant. + * + * It was derived from a Hermitian construction setting the first derivative + * at each sample position to the linear slope between neighboring positions + * over their parameter interval. + * + * @author tschw + */ + + function CubicInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer ); + + this._weightPrev = - 0; + this._offsetPrev = - 0; + this._weightNext = - 0; + this._offsetNext = - 0; + + } + + CubicInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), { + + constructor: CubicInterpolant, + + DefaultSettings_: { + + endingStart: ZeroCurvatureEnding, + endingEnd: ZeroCurvatureEnding + + }, + + intervalChanged_: function ( i1, t0, t1 ) { + + var pp = this.parameterPositions, + iPrev = i1 - 2, + iNext = i1 + 1, + + tPrev = pp[ iPrev ], + tNext = pp[ iNext ]; + + if ( tPrev === undefined ) { + + switch ( this.getSettings_().endingStart ) { + + case ZeroSlopeEnding: + + // f'(t0) = 0 + iPrev = i1; + tPrev = 2 * t0 - t1; + + break; + + case WrapAroundEnding: + + // use the other end of the curve + iPrev = pp.length - 2; + tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ]; + + break; + + default: // ZeroCurvatureEnding + + // f''(t0) = 0 a.k.a. Natural Spline + iPrev = i1; + tPrev = t1; + + } + + } + + if ( tNext === undefined ) { + + switch ( this.getSettings_().endingEnd ) { + + case ZeroSlopeEnding: + + // f'(tN) = 0 + iNext = i1; + tNext = 2 * t1 - t0; + + break; + + case WrapAroundEnding: + + // use the other end of the curve + iNext = 1; + tNext = t1 + pp[ 1 ] - pp[ 0 ]; + + break; + + default: // ZeroCurvatureEnding + + // f''(tN) = 0, a.k.a. Natural Spline + iNext = i1 - 1; + tNext = t0; + + } + + } + + var halfDt = ( t1 - t0 ) * 0.5, + stride = this.valueSize; + + this._weightPrev = halfDt / ( t0 - tPrev ); + this._weightNext = halfDt / ( tNext - t1 ); + this._offsetPrev = iPrev * stride; + this._offsetNext = iNext * stride; + + }, + + interpolate_: function ( i1, t0, t, t1 ) { + + var result = this.resultBuffer, + values = this.sampleValues, + stride = this.valueSize, + + o1 = i1 * stride, o0 = o1 - stride, + oP = this._offsetPrev, oN = this._offsetNext, + wP = this._weightPrev, wN = this._weightNext, + + p = ( t - t0 ) / ( t1 - t0 ), + pp = p * p, + ppp = pp * p; + + // evaluate polynomials + + var sP = - wP * ppp + 2 * wP * pp - wP * p; + var s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1; + var s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p; + var sN = wN * ppp - wN * pp; + + // combine data linearly + + for ( var i = 0; i !== stride; ++ i ) { + + result[ i ] = + sP * values[ oP + i ] + + s0 * values[ o0 + i ] + + s1 * values[ o1 + i ] + + sN * values[ oN + i ]; + + } + + return result; + + } + + } ); + + /** + * @author tschw + */ + + function LinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer ); + + } + + LinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), { + + constructor: LinearInterpolant, + + interpolate_: function ( i1, t0, t, t1 ) { + + var result = this.resultBuffer, + values = this.sampleValues, + stride = this.valueSize, + + offset1 = i1 * stride, + offset0 = offset1 - stride, + + weight1 = ( t - t0 ) / ( t1 - t0 ), + weight0 = 1 - weight1; + + for ( var i = 0; i !== stride; ++ i ) { + + result[ i ] = + values[ offset0 + i ] * weight0 + + values[ offset1 + i ] * weight1; + + } + + return result; + + } + + } ); + + /** + * + * Interpolant that evaluates to the sample value at the position preceeding + * the parameter. + * + * @author tschw + */ + + function DiscreteInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) { + + Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer ); + + } + + DiscreteInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), { + + constructor: DiscreteInterpolant, + + interpolate_: function ( i1 /*, t0, t, t1 */ ) { + + return this.copySampleValue_( i1 - 1 ); + + } + + } ); + + /** + * @author tschw + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + */ + + var AnimationUtils = { + + // same as Array.prototype.slice, but also works on typed arrays + arraySlice: function ( array, from, to ) { + + if ( AnimationUtils.isTypedArray( array ) ) { + + // in ios9 array.subarray(from, undefined) will return empty array + // but array.subarray(from) or array.subarray(from, len) is correct + return new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) ); + + } + + return array.slice( from, to ); + + }, + + // converts an array to a specific type + convertArray: function ( array, type, forceClone ) { + + if ( ! array || // let 'undefined' and 'null' pass + ! forceClone && array.constructor === type ) return array; + + if ( typeof type.BYTES_PER_ELEMENT === 'number' ) { + + return new type( array ); // create typed array + + } + + return Array.prototype.slice.call( array ); // create Array + + }, + + isTypedArray: function ( object ) { + + return ArrayBuffer.isView( object ) && + ! ( object instanceof DataView ); + + }, + + // returns an array by which times and values can be sorted + getKeyframeOrder: function ( times ) { + + function compareTime( i, j ) { + + return times[ i ] - times[ j ]; + + } + + var n = times.length; + var result = new Array( n ); + for ( var i = 0; i !== n; ++ i ) result[ i ] = i; + + result.sort( compareTime ); + + return result; + + }, + + // uses the array previously returned by 'getKeyframeOrder' to sort data + sortedArray: function ( values, stride, order ) { + + var nValues = values.length; + var result = new values.constructor( nValues ); + + for ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) { + + var srcOffset = order[ i ] * stride; + + for ( var j = 0; j !== stride; ++ j ) { + + result[ dstOffset ++ ] = values[ srcOffset + j ]; + + } + + } + + return result; + + }, + + // function for parsing AOS keyframe formats + flattenJSON: function ( jsonKeys, times, values, valuePropertyName ) { + + var i = 1, key = jsonKeys[ 0 ]; + + while ( key !== undefined && key[ valuePropertyName ] === undefined ) { + + key = jsonKeys[ i ++ ]; + + } + + if ( key === undefined ) return; // no data + + var value = key[ valuePropertyName ]; + if ( value === undefined ) return; // no data + + if ( Array.isArray( value ) ) { + + do { + + value = key[ valuePropertyName ]; + + if ( value !== undefined ) { + + times.push( key.time ); + values.push.apply( values, value ); // push all elements + + } + + key = jsonKeys[ i ++ ]; + + } while ( key !== undefined ); + + } else if ( value.toArray !== undefined ) { + + // ...assume THREE.Math-ish + + do { + + value = key[ valuePropertyName ]; + + if ( value !== undefined ) { + + times.push( key.time ); + value.toArray( values, values.length ); + + } + + key = jsonKeys[ i ++ ]; + + } while ( key !== undefined ); + + } else { + + // otherwise push as-is + + do { + + value = key[ valuePropertyName ]; + + if ( value !== undefined ) { + + times.push( key.time ); + values.push( value ); + + } + + key = jsonKeys[ i ++ ]; + + } while ( key !== undefined ); + + } + + } + + }; + + /** + * + * A timed sequence of keyframes for a specific property. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function KeyframeTrack( name, times, values, interpolation ) { + + if ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' ); + if ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name ); + + this.name = name; + + this.times = AnimationUtils.convertArray( times, this.TimeBufferType ); + this.values = AnimationUtils.convertArray( values, this.ValueBufferType ); + + this.setInterpolation( interpolation || this.DefaultInterpolation ); + + this.validate(); + this.optimize(); + + } + + // Static methods: + + Object.assign( KeyframeTrack, { + + // Serialization (in static context, because of constructor invocation + // and automatic invocation of .toJSON): + + parse: function ( json ) { + + if ( json.type === undefined ) { + + throw new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' ); + + } + + var trackType = KeyframeTrack._getTrackTypeForValueTypeName( json.type ); + + if ( json.times === undefined ) { + + var times = [], values = []; + + AnimationUtils.flattenJSON( json.keys, times, values, 'value' ); + + json.times = times; + json.values = values; + + } + + // derived classes can define a static parse method + if ( trackType.parse !== undefined ) { + + return trackType.parse( json ); + + } else { + + // by default, we assume a constructor compatible with the base + return new trackType( json.name, json.times, json.values, json.interpolation ); + + } + + }, + + toJSON: function ( track ) { + + var trackType = track.constructor; + + var json; + + // derived classes can define a static toJSON method + if ( trackType.toJSON !== undefined ) { + + json = trackType.toJSON( track ); + + } else { + + // by default, we assume the data can be serialized as-is + json = { + + 'name': track.name, + 'times': AnimationUtils.convertArray( track.times, Array ), + 'values': AnimationUtils.convertArray( track.values, Array ) + + }; + + var interpolation = track.getInterpolation(); + + if ( interpolation !== track.DefaultInterpolation ) { + + json.interpolation = interpolation; + + } + + } + + json.type = track.ValueTypeName; // mandatory + + return json; + + }, + + _getTrackTypeForValueTypeName: function ( typeName ) { + + switch ( typeName.toLowerCase() ) { + + case 'scalar': + case 'double': + case 'float': + case 'number': + case 'integer': + + return NumberKeyframeTrack; + + case 'vector': + case 'vector2': + case 'vector3': + case 'vector4': + + return VectorKeyframeTrack; + + case 'color': + + return ColorKeyframeTrack; + + case 'quaternion': + + return QuaternionKeyframeTrack; + + case 'bool': + case 'boolean': + + return BooleanKeyframeTrack; + + case 'string': + + return StringKeyframeTrack; + + } + + throw new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName ); + + } + + } ); + + Object.assign( KeyframeTrack.prototype, { + + constructor: KeyframeTrack, + + TimeBufferType: Float32Array, + + ValueBufferType: Float32Array, + + DefaultInterpolation: InterpolateLinear, + + InterpolantFactoryMethodDiscrete: function ( result ) { + + return new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result ); + + }, + + InterpolantFactoryMethodLinear: function ( result ) { + + return new LinearInterpolant( this.times, this.values, this.getValueSize(), result ); + + }, + + InterpolantFactoryMethodSmooth: function ( result ) { + + return new CubicInterpolant( this.times, this.values, this.getValueSize(), result ); + + }, + + setInterpolation: function ( interpolation ) { + + var factoryMethod; + + switch ( interpolation ) { + + case InterpolateDiscrete: + + factoryMethod = this.InterpolantFactoryMethodDiscrete; + + break; + + case InterpolateLinear: + + factoryMethod = this.InterpolantFactoryMethodLinear; + + break; + + case InterpolateSmooth: + + factoryMethod = this.InterpolantFactoryMethodSmooth; + + break; + + } + + if ( factoryMethod === undefined ) { + + var message = "unsupported interpolation for " + + this.ValueTypeName + " keyframe track named " + this.name; + + if ( this.createInterpolant === undefined ) { + + // fall back to default, unless the default itself is messed up + if ( interpolation !== this.DefaultInterpolation ) { + + this.setInterpolation( this.DefaultInterpolation ); + + } else { + + throw new Error( message ); // fatal, in this case + + } + + } + + console.warn( 'THREE.KeyframeTrack:', message ); + return; + + } + + this.createInterpolant = factoryMethod; + + }, + + getInterpolation: function () { + + switch ( this.createInterpolant ) { + + case this.InterpolantFactoryMethodDiscrete: + + return InterpolateDiscrete; + + case this.InterpolantFactoryMethodLinear: + + return InterpolateLinear; + + case this.InterpolantFactoryMethodSmooth: + + return InterpolateSmooth; + + } + + }, + + getValueSize: function () { + + return this.values.length / this.times.length; + + }, + + // move all keyframes either forwards or backwards in time + shift: function ( timeOffset ) { + + if ( timeOffset !== 0.0 ) { + + var times = this.times; + + for ( var i = 0, n = times.length; i !== n; ++ i ) { + + times[ i ] += timeOffset; + + } + + } + + return this; + + }, + + // scale all keyframe times by a factor (useful for frame <-> seconds conversions) + scale: function ( timeScale ) { + + if ( timeScale !== 1.0 ) { + + var times = this.times; + + for ( var i = 0, n = times.length; i !== n; ++ i ) { + + times[ i ] *= timeScale; + + } + + } + + return this; + + }, + + // removes keyframes before and after animation without changing any values within the range [startTime, endTime]. + // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values + trim: function ( startTime, endTime ) { + + var times = this.times, + nKeys = times.length, + from = 0, + to = nKeys - 1; + + while ( from !== nKeys && times[ from ] < startTime ) { + + ++ from; + + } + + while ( to !== - 1 && times[ to ] > endTime ) { + + -- to; + + } + + ++ to; // inclusive -> exclusive bound + + if ( from !== 0 || to !== nKeys ) { + + // empty tracks are forbidden, so keep at least one keyframe + if ( from >= to ) to = Math.max( to, 1 ), from = to - 1; + + var stride = this.getValueSize(); + this.times = AnimationUtils.arraySlice( times, from, to ); + this.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride ); + + } + + return this; + + }, + + // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable + validate: function () { + + var valid = true; + + var valueSize = this.getValueSize(); + if ( valueSize - Math.floor( valueSize ) !== 0 ) { + + console.error( 'THREE.KeyframeTrack: Invalid value size in track.', this ); + valid = false; + + } + + var times = this.times, + values = this.values, + + nKeys = times.length; + + if ( nKeys === 0 ) { + + console.error( 'THREE.KeyframeTrack: Track is empty.', this ); + valid = false; + + } + + var prevTime = null; + + for ( var i = 0; i !== nKeys; i ++ ) { + + var currTime = times[ i ]; + + if ( typeof currTime === 'number' && isNaN( currTime ) ) { + + console.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime ); + valid = false; + break; + + } + + if ( prevTime !== null && prevTime > currTime ) { + + console.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime ); + valid = false; + break; + + } + + prevTime = currTime; + + } + + if ( values !== undefined ) { + + if ( AnimationUtils.isTypedArray( values ) ) { + + for ( var i = 0, n = values.length; i !== n; ++ i ) { + + var value = values[ i ]; + + if ( isNaN( value ) ) { + + console.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value ); + valid = false; + break; + + } + + } + + } + + } + + return valid; + + }, + + // removes equivalent sequential keys as common in morph target sequences + // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0) + optimize: function () { + + var times = this.times, + values = this.values, + stride = this.getValueSize(), + + smoothInterpolation = this.getInterpolation() === InterpolateSmooth, + + writeIndex = 1, + lastIndex = times.length - 1; + + for ( var i = 1; i < lastIndex; ++ i ) { + + var keep = false; + + var time = times[ i ]; + var timeNext = times[ i + 1 ]; + + // remove adjacent keyframes scheduled at the same time + + if ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) { + + if ( ! smoothInterpolation ) { + + // remove unnecessary keyframes same as their neighbors + + var offset = i * stride, + offsetP = offset - stride, + offsetN = offset + stride; + + for ( var j = 0; j !== stride; ++ j ) { + + var value = values[ offset + j ]; + + if ( value !== values[ offsetP + j ] || + value !== values[ offsetN + j ] ) { + + keep = true; + break; + + } + + } + + } else { + + keep = true; + + } + + } + + // in-place compaction + + if ( keep ) { + + if ( i !== writeIndex ) { + + times[ writeIndex ] = times[ i ]; + + var readOffset = i * stride, + writeOffset = writeIndex * stride; + + for ( var j = 0; j !== stride; ++ j ) { + + values[ writeOffset + j ] = values[ readOffset + j ]; + + } + + } + + ++ writeIndex; + + } + + } + + // flush last keyframe (compaction looks ahead) + + if ( lastIndex > 0 ) { + + times[ writeIndex ] = times[ lastIndex ]; + + for ( var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) { + + values[ writeOffset + j ] = values[ readOffset + j ]; + + } + + ++ writeIndex; + + } + + if ( writeIndex !== times.length ) { + + this.times = AnimationUtils.arraySlice( times, 0, writeIndex ); + this.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride ); + + } + + return this; + + } + + } ); + + /** + * + * A Track of vectored keyframe values. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function VectorKeyframeTrack( name, times, values, interpolation ) { + + KeyframeTrack.call( this, name, times, values, interpolation ); + + } + + VectorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), { + + constructor: VectorKeyframeTrack, + + ValueTypeName: 'vector' + + // ValueBufferType is inherited + + // DefaultInterpolation is inherited + + } ); + + /** + * + * Reusable set of Tracks that represent an animation. + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + */ + + function AnimationClip( name, duration, tracks ) { + + this.name = name; + this.tracks = tracks; + this.duration = ( duration !== undefined ) ? duration : - 1; + + this.uuid = _Math.generateUUID(); + + // this means it should figure out its duration by scanning the tracks + if ( this.duration < 0 ) { + + this.resetDuration(); + + } + + this.optimize(); + + } + + Object.assign( AnimationClip, { + + parse: function ( json ) { + + var tracks = [], + jsonTracks = json.tracks, + frameTime = 1.0 / ( json.fps || 1.0 ); + + for ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) { + + tracks.push( KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) ); + + } + + return new AnimationClip( json.name, json.duration, tracks ); + + }, + + toJSON: function ( clip ) { + + var tracks = [], + clipTracks = clip.tracks; + + var json = { + + 'name': clip.name, + 'duration': clip.duration, + 'tracks': tracks + + }; + + for ( var i = 0, n = clipTracks.length; i !== n; ++ i ) { + + tracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) ); + + } + + return json; + + }, + + CreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) { + + var numMorphTargets = morphTargetSequence.length; + var tracks = []; + + for ( var i = 0; i < numMorphTargets; i ++ ) { + + var times = []; + var values = []; + + times.push( + ( i + numMorphTargets - 1 ) % numMorphTargets, + i, + ( i + 1 ) % numMorphTargets ); + + values.push( 0, 1, 0 ); + + var order = AnimationUtils.getKeyframeOrder( times ); + times = AnimationUtils.sortedArray( times, 1, order ); + values = AnimationUtils.sortedArray( values, 1, order ); + + // if there is a key at the first frame, duplicate it as the + // last frame as well for perfect loop. + if ( ! noLoop && times[ 0 ] === 0 ) { + + times.push( numMorphTargets ); + values.push( values[ 0 ] ); + + } + + tracks.push( + new NumberKeyframeTrack( + '.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']', + times, values + ).scale( 1.0 / fps ) ); + + } + + return new AnimationClip( name, - 1, tracks ); + + }, + + findByName: function ( objectOrClipArray, name ) { + + var clipArray = objectOrClipArray; + + if ( ! Array.isArray( objectOrClipArray ) ) { + + var o = objectOrClipArray; + clipArray = o.geometry && o.geometry.animations || o.animations; + + } + + for ( var i = 0; i < clipArray.length; i ++ ) { + + if ( clipArray[ i ].name === name ) { + + return clipArray[ i ]; + + } + + } + + return null; + + }, + + CreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) { + + var animationToMorphTargets = {}; + + // tested with https://regex101.com/ on trick sequences + // such flamingo_flyA_003, flamingo_run1_003, crdeath0059 + var pattern = /^([\w-]*?)([\d]+)$/; + + // sort morph target names into animation groups based + // patterns like Walk_001, Walk_002, Run_001, Run_002 + for ( var i = 0, il = morphTargets.length; i < il; i ++ ) { + + var morphTarget = morphTargets[ i ]; + var parts = morphTarget.name.match( pattern ); + + if ( parts && parts.length > 1 ) { + + var name = parts[ 1 ]; + + var animationMorphTargets = animationToMorphTargets[ name ]; + if ( ! animationMorphTargets ) { + + animationToMorphTargets[ name ] = animationMorphTargets = []; + + } + + animationMorphTargets.push( morphTarget ); + + } + + } + + var clips = []; + + for ( var name in animationToMorphTargets ) { + + clips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) ); + + } + + return clips; + + }, + + // parse the animation.hierarchy format + parseAnimation: function ( animation, bones ) { + + if ( ! animation ) { + + console.error( 'THREE.AnimationClip: No animation in JSONLoader data.' ); + return null; + + } + + var addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) { + + // only return track if there are actually keys. + if ( animationKeys.length !== 0 ) { + + var times = []; + var values = []; + + AnimationUtils.flattenJSON( animationKeys, times, values, propertyName ); + + // empty keys are filtered out, so check again + if ( times.length !== 0 ) { + + destTracks.push( new trackType( trackName, times, values ) ); + + } + + } + + }; + + var tracks = []; + + var clipName = animation.name || 'default'; + // automatic length determination in AnimationClip. + var duration = animation.length || - 1; + var fps = animation.fps || 30; + + var hierarchyTracks = animation.hierarchy || []; + + for ( var h = 0; h < hierarchyTracks.length; h ++ ) { + + var animationKeys = hierarchyTracks[ h ].keys; + + // skip empty tracks + if ( ! animationKeys || animationKeys.length === 0 ) continue; + + // process morph targets + if ( animationKeys[ 0 ].morphTargets ) { + + // figure out all morph targets used in this track + var morphTargetNames = {}; + + for ( var k = 0; k < animationKeys.length; k ++ ) { + + if ( animationKeys[ k ].morphTargets ) { + + for ( var m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) { + + morphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1; + + } + + } + + } + + // create a track for each morph target with all zero + // morphTargetInfluences except for the keys in which + // the morphTarget is named. + for ( var morphTargetName in morphTargetNames ) { + + var times = []; + var values = []; + + for ( var m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) { + + var animationKey = animationKeys[ k ]; + + times.push( animationKey.time ); + values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 ); + + } + + tracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) ); + + } + + duration = morphTargetNames.length * ( fps || 1.0 ); + + } else { + + // ...assume skeletal animation + + var boneName = '.bones[' + bones[ h ].name + ']'; + + addNonemptyTrack( + VectorKeyframeTrack, boneName + '.position', + animationKeys, 'pos', tracks ); + + addNonemptyTrack( + QuaternionKeyframeTrack, boneName + '.quaternion', + animationKeys, 'rot', tracks ); + + addNonemptyTrack( + VectorKeyframeTrack, boneName + '.scale', + animationKeys, 'scl', tracks ); + + } + + } + + if ( tracks.length === 0 ) { + + return null; + + } + + var clip = new AnimationClip( clipName, duration, tracks ); + + return clip; + + } + + } ); + + Object.assign( AnimationClip.prototype, { + + resetDuration: function () { + + var tracks = this.tracks, duration = 0; + + for ( var i = 0, n = tracks.length; i !== n; ++ i ) { + + var track = this.tracks[ i ]; + + duration = Math.max( duration, track.times[ track.times.length - 1 ] ); + + } + + this.duration = duration; + + }, + + trim: function () { + + for ( var i = 0; i < this.tracks.length; i ++ ) { + + this.tracks[ i ].trim( 0, this.duration ); + + } + + return this; + + }, + + optimize: function () { + + for ( var i = 0; i < this.tracks.length; i ++ ) { + + this.tracks[ i ].optimize(); + + } + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function MaterialLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + this.textures = {}; + + } + + Object.assign( MaterialLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var loader = new FileLoader( scope.manager ); + loader.load( url, function ( text ) { + + onLoad( scope.parse( JSON.parse( text ) ) ); + + }, onProgress, onError ); + + }, + + setTextures: function ( value ) { + + this.textures = value; + + }, + + parse: function ( json ) { + + var textures = this.textures; + + function getTexture( name ) { + + if ( textures[ name ] === undefined ) { + + console.warn( 'THREE.MaterialLoader: Undefined texture', name ); + + } + + return textures[ name ]; + + } + + var material = new Materials[ json.type ](); + + if ( json.uuid !== undefined ) material.uuid = json.uuid; + if ( json.name !== undefined ) material.name = json.name; + if ( json.color !== undefined ) material.color.setHex( json.color ); + if ( json.roughness !== undefined ) material.roughness = json.roughness; + if ( json.metalness !== undefined ) material.metalness = json.metalness; + if ( json.emissive !== undefined ) material.emissive.setHex( json.emissive ); + if ( json.specular !== undefined ) material.specular.setHex( json.specular ); + if ( json.shininess !== undefined ) material.shininess = json.shininess; + if ( json.clearCoat !== undefined ) material.clearCoat = json.clearCoat; + if ( json.clearCoatRoughness !== undefined ) material.clearCoatRoughness = json.clearCoatRoughness; + if ( json.uniforms !== undefined ) material.uniforms = json.uniforms; + if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader; + if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader; + if ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors; + if ( json.fog !== undefined ) material.fog = json.fog; + if ( json.flatShading !== undefined ) material.flatShading = json.flatShading; + if ( json.blending !== undefined ) material.blending = json.blending; + if ( json.side !== undefined ) material.side = json.side; + if ( json.opacity !== undefined ) material.opacity = json.opacity; + if ( json.transparent !== undefined ) material.transparent = json.transparent; + if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest; + if ( json.depthTest !== undefined ) material.depthTest = json.depthTest; + if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite; + if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite; + if ( json.wireframe !== undefined ) material.wireframe = json.wireframe; + if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth; + if ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap; + if ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin; + + if ( json.rotation !== undefined ) material.rotation = json.rotation; + + if ( json.linewidth !== 1 ) material.linewidth = json.linewidth; + if ( json.dashSize !== undefined ) material.dashSize = json.dashSize; + if ( json.gapSize !== undefined ) material.gapSize = json.gapSize; + if ( json.scale !== undefined ) material.scale = json.scale; + + if ( json.skinning !== undefined ) material.skinning = json.skinning; + if ( json.morphTargets !== undefined ) material.morphTargets = json.morphTargets; + if ( json.dithering !== undefined ) material.dithering = json.dithering; + + if ( json.visible !== undefined ) material.visible = json.visible; + if ( json.userData !== undefined ) material.userData = json.userData; + + // Deprecated + + if ( json.shading !== undefined ) material.flatShading = json.shading === 1; // THREE.FlatShading + + // for PointsMaterial + + if ( json.size !== undefined ) material.size = json.size; + if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation; + + // maps + + if ( json.map !== undefined ) material.map = getTexture( json.map ); + + if ( json.alphaMap !== undefined ) { + + material.alphaMap = getTexture( json.alphaMap ); + material.transparent = true; + + } + + if ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap ); + if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale; + + if ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap ); + if ( json.normalScale !== undefined ) { + + var normalScale = json.normalScale; + + if ( Array.isArray( normalScale ) === false ) { + + // Blender exporter used to export a scalar. See #7459 + + normalScale = [ normalScale, normalScale ]; + + } + + material.normalScale = new Vector2().fromArray( normalScale ); + + } + + if ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap ); + if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale; + if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias; + + if ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap ); + if ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap ); + + if ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap ); + if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity; + + if ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap ); + + if ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap ); + + if ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity; + + if ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap ); + if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity; + + if ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap ); + if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity; + + if ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap ); + + return material; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function BufferGeometryLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( BufferGeometryLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var loader = new FileLoader( scope.manager ); + loader.load( url, function ( text ) { + + onLoad( scope.parse( JSON.parse( text ) ) ); + + }, onProgress, onError ); + + }, + + parse: function ( json ) { + + var geometry = new BufferGeometry(); + + var index = json.data.index; + + if ( index !== undefined ) { + + var typedArray = new TYPED_ARRAYS[ index.type ]( index.array ); + geometry.setIndex( new BufferAttribute( typedArray, 1 ) ); + + } + + var attributes = json.data.attributes; + + for ( var key in attributes ) { + + var attribute = attributes[ key ]; + var typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array ); + + geometry.addAttribute( key, new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized ) ); + + } + + var groups = json.data.groups || json.data.drawcalls || json.data.offsets; + + if ( groups !== undefined ) { + + for ( var i = 0, n = groups.length; i !== n; ++ i ) { + + var group = groups[ i ]; + + geometry.addGroup( group.start, group.count, group.materialIndex ); + + } + + } + + var boundingSphere = json.data.boundingSphere; + + if ( boundingSphere !== undefined ) { + + var center = new Vector3(); + + if ( boundingSphere.center !== undefined ) { + + center.fromArray( boundingSphere.center ); + + } + + geometry.boundingSphere = new Sphere( center, boundingSphere.radius ); + + } + + return geometry; + + } + + } ); + + var TYPED_ARRAYS = { + Int8Array: Int8Array, + Uint8Array: Uint8Array, + // Workaround for IE11 pre KB2929437. See #11440 + Uint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array, + Int16Array: Int16Array, + Uint16Array: Uint16Array, + Int32Array: Int32Array, + Uint32Array: Uint32Array, + Float32Array: Float32Array, + Float64Array: Float64Array + }; + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function Loader() { + + this.onLoadStart = function () {}; + this.onLoadProgress = function () {}; + this.onLoadComplete = function () {}; + + } + + Loader.Handlers = { + + handlers: [], + + add: function ( regex, loader ) { + + this.handlers.push( regex, loader ); + + }, + + get: function ( file ) { + + var handlers = this.handlers; + + for ( var i = 0, l = handlers.length; i < l; i += 2 ) { + + var regex = handlers[ i ]; + var loader = handlers[ i + 1 ]; + + if ( regex.test( file ) ) { + + return loader; + + } + + } + + return null; + + } + + }; + + Object.assign( Loader.prototype, { + + crossOrigin: undefined, + + initMaterials: function ( materials, texturePath, crossOrigin ) { + + var array = []; + + for ( var i = 0; i < materials.length; ++ i ) { + + array[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin ); + + } + + return array; + + }, + + createMaterial: ( function () { + + var BlendingMode = { + NoBlending: NoBlending, + NormalBlending: NormalBlending, + AdditiveBlending: AdditiveBlending, + SubtractiveBlending: SubtractiveBlending, + MultiplyBlending: MultiplyBlending, + CustomBlending: CustomBlending + }; + + var color = new Color(); + var textureLoader = new TextureLoader(); + var materialLoader = new MaterialLoader(); + + return function createMaterial( m, texturePath, crossOrigin ) { + + // convert from old material format + + var textures = {}; + + function loadTexture( path, repeat, offset, wrap, anisotropy ) { + + var fullPath = texturePath + path; + var loader = Loader.Handlers.get( fullPath ); + + var texture; + + if ( loader !== null ) { + + texture = loader.load( fullPath ); + + } else { + + textureLoader.setCrossOrigin( crossOrigin ); + texture = textureLoader.load( fullPath ); + + } + + if ( repeat !== undefined ) { + + texture.repeat.fromArray( repeat ); + + if ( repeat[ 0 ] !== 1 ) texture.wrapS = RepeatWrapping; + if ( repeat[ 1 ] !== 1 ) texture.wrapT = RepeatWrapping; + + } + + if ( offset !== undefined ) { + + texture.offset.fromArray( offset ); + + } + + if ( wrap !== undefined ) { + + if ( wrap[ 0 ] === 'repeat' ) texture.wrapS = RepeatWrapping; + if ( wrap[ 0 ] === 'mirror' ) texture.wrapS = MirroredRepeatWrapping; + + if ( wrap[ 1 ] === 'repeat' ) texture.wrapT = RepeatWrapping; + if ( wrap[ 1 ] === 'mirror' ) texture.wrapT = MirroredRepeatWrapping; + + } + + if ( anisotropy !== undefined ) { + + texture.anisotropy = anisotropy; + + } + + var uuid = _Math.generateUUID(); + + textures[ uuid ] = texture; + + return uuid; + + } + + // + + var json = { + uuid: _Math.generateUUID(), + type: 'MeshLambertMaterial' + }; + + for ( var name in m ) { + + var value = m[ name ]; + + switch ( name ) { + + case 'DbgColor': + case 'DbgIndex': + case 'opticalDensity': + case 'illumination': + break; + case 'DbgName': + json.name = value; + break; + case 'blending': + json.blending = BlendingMode[ value ]; + break; + case 'colorAmbient': + case 'mapAmbient': + console.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' ); + break; + case 'colorDiffuse': + json.color = color.fromArray( value ).getHex(); + break; + case 'colorSpecular': + json.specular = color.fromArray( value ).getHex(); + break; + case 'colorEmissive': + json.emissive = color.fromArray( value ).getHex(); + break; + case 'specularCoef': + json.shininess = value; + break; + case 'shading': + if ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial'; + if ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial'; + if ( value.toLowerCase() === 'standard' ) json.type = 'MeshStandardMaterial'; + break; + case 'mapDiffuse': + json.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy ); + break; + case 'mapDiffuseRepeat': + case 'mapDiffuseOffset': + case 'mapDiffuseWrap': + case 'mapDiffuseAnisotropy': + break; + case 'mapEmissive': + json.emissiveMap = loadTexture( value, m.mapEmissiveRepeat, m.mapEmissiveOffset, m.mapEmissiveWrap, m.mapEmissiveAnisotropy ); + break; + case 'mapEmissiveRepeat': + case 'mapEmissiveOffset': + case 'mapEmissiveWrap': + case 'mapEmissiveAnisotropy': + break; + case 'mapLight': + json.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy ); + break; + case 'mapLightRepeat': + case 'mapLightOffset': + case 'mapLightWrap': + case 'mapLightAnisotropy': + break; + case 'mapAO': + json.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy ); + break; + case 'mapAORepeat': + case 'mapAOOffset': + case 'mapAOWrap': + case 'mapAOAnisotropy': + break; + case 'mapBump': + json.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy ); + break; + case 'mapBumpScale': + json.bumpScale = value; + break; + case 'mapBumpRepeat': + case 'mapBumpOffset': + case 'mapBumpWrap': + case 'mapBumpAnisotropy': + break; + case 'mapNormal': + json.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy ); + break; + case 'mapNormalFactor': + json.normalScale = [ value, value ]; + break; + case 'mapNormalRepeat': + case 'mapNormalOffset': + case 'mapNormalWrap': + case 'mapNormalAnisotropy': + break; + case 'mapSpecular': + json.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy ); + break; + case 'mapSpecularRepeat': + case 'mapSpecularOffset': + case 'mapSpecularWrap': + case 'mapSpecularAnisotropy': + break; + case 'mapMetalness': + json.metalnessMap = loadTexture( value, m.mapMetalnessRepeat, m.mapMetalnessOffset, m.mapMetalnessWrap, m.mapMetalnessAnisotropy ); + break; + case 'mapMetalnessRepeat': + case 'mapMetalnessOffset': + case 'mapMetalnessWrap': + case 'mapMetalnessAnisotropy': + break; + case 'mapRoughness': + json.roughnessMap = loadTexture( value, m.mapRoughnessRepeat, m.mapRoughnessOffset, m.mapRoughnessWrap, m.mapRoughnessAnisotropy ); + break; + case 'mapRoughnessRepeat': + case 'mapRoughnessOffset': + case 'mapRoughnessWrap': + case 'mapRoughnessAnisotropy': + break; + case 'mapAlpha': + json.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy ); + break; + case 'mapAlphaRepeat': + case 'mapAlphaOffset': + case 'mapAlphaWrap': + case 'mapAlphaAnisotropy': + break; + case 'flipSided': + json.side = BackSide; + break; + case 'doubleSided': + json.side = DoubleSide; + break; + case 'transparency': + console.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' ); + json.opacity = value; + break; + case 'depthTest': + case 'depthWrite': + case 'colorWrite': + case 'opacity': + case 'reflectivity': + case 'transparent': + case 'visible': + case 'wireframe': + json[ name ] = value; + break; + case 'vertexColors': + if ( value === true ) json.vertexColors = VertexColors; + if ( value === 'face' ) json.vertexColors = FaceColors; + break; + default: + console.error( 'THREE.Loader.createMaterial: Unsupported', name, value ); + break; + + } + + } + + if ( json.type === 'MeshBasicMaterial' ) delete json.emissive; + if ( json.type !== 'MeshPhongMaterial' ) delete json.specular; + + if ( json.opacity < 1 ) json.transparent = true; + + materialLoader.setTextures( textures ); + + return materialLoader.parse( json ); + + }; + + } )() + + } ); + + /** + * @author Don McCurdy / https://www.donmccurdy.com + */ + + var LoaderUtils = { + + decodeText: function ( array ) { + + if ( typeof TextDecoder !== 'undefined' ) { + + return new TextDecoder().decode( array ); + + } + + // Avoid the String.fromCharCode.apply(null, array) shortcut, which + // throws a "maximum call stack size exceeded" error for large arrays. + + var s = ''; + + for ( var i = 0, il = array.length; i < il; i ++ ) { + + // Implicitly assumes little-endian. + s += String.fromCharCode( array[ i ] ); + + } + + return s; + + }, + + extractUrlBase: function ( url ) { + + var parts = url.split( '/' ); + + if ( parts.length === 1 ) return './'; + + parts.pop(); + + return parts.join( '/' ) + '/'; + + } + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author alteredq / http://alteredqualia.com/ + */ + + function JSONLoader( manager ) { + + if ( typeof manager === 'boolean' ) { + + console.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' ); + manager = undefined; + + } + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + this.withCredentials = false; + + } + + Object.assign( JSONLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var texturePath = this.texturePath && ( typeof this.texturePath === 'string' ) ? this.texturePath : LoaderUtils.extractUrlBase( url ); + + var loader = new FileLoader( this.manager ); + loader.setWithCredentials( this.withCredentials ); + loader.load( url, function ( text ) { + + var json = JSON.parse( text ); + var metadata = json.metadata; + + if ( metadata !== undefined ) { + + var type = metadata.type; + + if ( type !== undefined ) { + + if ( type.toLowerCase() === 'object' ) { + + console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' ); + return; + + } + + if ( type.toLowerCase() === 'scene' ) { + + console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' ); + return; + + } + + } + + } + + var object = scope.parse( json, texturePath ); + onLoad( object.geometry, object.materials ); + + }, onProgress, onError ); + + }, + + setTexturePath: function ( value ) { + + this.texturePath = value; + + }, + + parse: ( function () { + + function parseModel( json, geometry ) { + + function isBitSet( value, position ) { + + return value & ( 1 << position ); + + } + + var i, j, fi, + + offset, zLength, + + colorIndex, normalIndex, uvIndex, materialIndex, + + type, + isQuad, + hasMaterial, + hasFaceVertexUv, + hasFaceNormal, hasFaceVertexNormal, + hasFaceColor, hasFaceVertexColor, + + vertex, face, faceA, faceB, hex, normal, + + uvLayer, uv, u, v, + + faces = json.faces, + vertices = json.vertices, + normals = json.normals, + colors = json.colors, + + scale = json.scale, + + nUvLayers = 0; + + + if ( json.uvs !== undefined ) { + + // disregard empty arrays + + for ( i = 0; i < json.uvs.length; i ++ ) { + + if ( json.uvs[ i ].length ) nUvLayers ++; + + } + + for ( i = 0; i < nUvLayers; i ++ ) { + + geometry.faceVertexUvs[ i ] = []; + + } + + } + + offset = 0; + zLength = vertices.length; + + while ( offset < zLength ) { + + vertex = new Vector3(); + + vertex.x = vertices[ offset ++ ] * scale; + vertex.y = vertices[ offset ++ ] * scale; + vertex.z = vertices[ offset ++ ] * scale; + + geometry.vertices.push( vertex ); + + } + + offset = 0; + zLength = faces.length; + + while ( offset < zLength ) { + + type = faces[ offset ++ ]; + + isQuad = isBitSet( type, 0 ); + hasMaterial = isBitSet( type, 1 ); + hasFaceVertexUv = isBitSet( type, 3 ); + hasFaceNormal = isBitSet( type, 4 ); + hasFaceVertexNormal = isBitSet( type, 5 ); + hasFaceColor = isBitSet( type, 6 ); + hasFaceVertexColor = isBitSet( type, 7 ); + + // console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor); + + if ( isQuad ) { + + faceA = new Face3(); + faceA.a = faces[ offset ]; + faceA.b = faces[ offset + 1 ]; + faceA.c = faces[ offset + 3 ]; + + faceB = new Face3(); + faceB.a = faces[ offset + 1 ]; + faceB.b = faces[ offset + 2 ]; + faceB.c = faces[ offset + 3 ]; + + offset += 4; + + if ( hasMaterial ) { + + materialIndex = faces[ offset ++ ]; + faceA.materialIndex = materialIndex; + faceB.materialIndex = materialIndex; + + } + + // to get face <=> uv index correspondence + + fi = geometry.faces.length; + + if ( hasFaceVertexUv ) { + + for ( i = 0; i < nUvLayers; i ++ ) { + + uvLayer = json.uvs[ i ]; + + geometry.faceVertexUvs[ i ][ fi ] = []; + geometry.faceVertexUvs[ i ][ fi + 1 ] = []; + + for ( j = 0; j < 4; j ++ ) { + + uvIndex = faces[ offset ++ ]; + + u = uvLayer[ uvIndex * 2 ]; + v = uvLayer[ uvIndex * 2 + 1 ]; + + uv = new Vector2( u, v ); + + if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv ); + if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv ); + + } + + } + + } + + if ( hasFaceNormal ) { + + normalIndex = faces[ offset ++ ] * 3; + + faceA.normal.set( + normals[ normalIndex ++ ], + normals[ normalIndex ++ ], + normals[ normalIndex ] + ); + + faceB.normal.copy( faceA.normal ); + + } + + if ( hasFaceVertexNormal ) { + + for ( i = 0; i < 4; i ++ ) { + + normalIndex = faces[ offset ++ ] * 3; + + normal = new Vector3( + normals[ normalIndex ++ ], + normals[ normalIndex ++ ], + normals[ normalIndex ] + ); + + + if ( i !== 2 ) faceA.vertexNormals.push( normal ); + if ( i !== 0 ) faceB.vertexNormals.push( normal ); + + } + + } + + + if ( hasFaceColor ) { + + colorIndex = faces[ offset ++ ]; + hex = colors[ colorIndex ]; + + faceA.color.setHex( hex ); + faceB.color.setHex( hex ); + + } + + + if ( hasFaceVertexColor ) { + + for ( i = 0; i < 4; i ++ ) { + + colorIndex = faces[ offset ++ ]; + hex = colors[ colorIndex ]; + + if ( i !== 2 ) faceA.vertexColors.push( new Color( hex ) ); + if ( i !== 0 ) faceB.vertexColors.push( new Color( hex ) ); + + } + + } + + geometry.faces.push( faceA ); + geometry.faces.push( faceB ); + + } else { + + face = new Face3(); + face.a = faces[ offset ++ ]; + face.b = faces[ offset ++ ]; + face.c = faces[ offset ++ ]; + + if ( hasMaterial ) { + + materialIndex = faces[ offset ++ ]; + face.materialIndex = materialIndex; + + } + + // to get face <=> uv index correspondence + + fi = geometry.faces.length; + + if ( hasFaceVertexUv ) { + + for ( i = 0; i < nUvLayers; i ++ ) { + + uvLayer = json.uvs[ i ]; + + geometry.faceVertexUvs[ i ][ fi ] = []; + + for ( j = 0; j < 3; j ++ ) { + + uvIndex = faces[ offset ++ ]; + + u = uvLayer[ uvIndex * 2 ]; + v = uvLayer[ uvIndex * 2 + 1 ]; + + uv = new Vector2( u, v ); + + geometry.faceVertexUvs[ i ][ fi ].push( uv ); + + } + + } + + } + + if ( hasFaceNormal ) { + + normalIndex = faces[ offset ++ ] * 3; + + face.normal.set( + normals[ normalIndex ++ ], + normals[ normalIndex ++ ], + normals[ normalIndex ] + ); + + } + + if ( hasFaceVertexNormal ) { + + for ( i = 0; i < 3; i ++ ) { + + normalIndex = faces[ offset ++ ] * 3; + + normal = new Vector3( + normals[ normalIndex ++ ], + normals[ normalIndex ++ ], + normals[ normalIndex ] + ); + + face.vertexNormals.push( normal ); + + } + + } + + + if ( hasFaceColor ) { + + colorIndex = faces[ offset ++ ]; + face.color.setHex( colors[ colorIndex ] ); + + } + + + if ( hasFaceVertexColor ) { + + for ( i = 0; i < 3; i ++ ) { + + colorIndex = faces[ offset ++ ]; + face.vertexColors.push( new Color( colors[ colorIndex ] ) ); + + } + + } + + geometry.faces.push( face ); + + } + + } + + } + + function parseSkin( json, geometry ) { + + var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2; + + if ( json.skinWeights ) { + + for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) { + + var x = json.skinWeights[ i ]; + var y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0; + var z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0; + var w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0; + + geometry.skinWeights.push( new Vector4( x, y, z, w ) ); + + } + + } + + if ( json.skinIndices ) { + + for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) { + + var a = json.skinIndices[ i ]; + var b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0; + var c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0; + var d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0; + + geometry.skinIndices.push( new Vector4( a, b, c, d ) ); + + } + + } + + geometry.bones = json.bones; + + if ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) { + + console.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' + + geometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' ); + + } + + } + + function parseMorphing( json, geometry ) { + + var scale = json.scale; + + if ( json.morphTargets !== undefined ) { + + for ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) { + + geometry.morphTargets[ i ] = {}; + geometry.morphTargets[ i ].name = json.morphTargets[ i ].name; + geometry.morphTargets[ i ].vertices = []; + + var dstVertices = geometry.morphTargets[ i ].vertices; + var srcVertices = json.morphTargets[ i ].vertices; + + for ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) { + + var vertex = new Vector3(); + vertex.x = srcVertices[ v ] * scale; + vertex.y = srcVertices[ v + 1 ] * scale; + vertex.z = srcVertices[ v + 2 ] * scale; + + dstVertices.push( vertex ); + + } + + } + + } + + if ( json.morphColors !== undefined && json.morphColors.length > 0 ) { + + console.warn( 'THREE.JSONLoader: "morphColors" no longer supported. Using them as face colors.' ); + + var faces = geometry.faces; + var morphColors = json.morphColors[ 0 ].colors; + + for ( var i = 0, l = faces.length; i < l; i ++ ) { + + faces[ i ].color.fromArray( morphColors, i * 3 ); + + } + + } + + } + + function parseAnimations( json, geometry ) { + + var outputAnimations = []; + + // parse old style Bone/Hierarchy animations + var animations = []; + + if ( json.animation !== undefined ) { + + animations.push( json.animation ); + + } + + if ( json.animations !== undefined ) { + + if ( json.animations.length ) { + + animations = animations.concat( json.animations ); + + } else { + + animations.push( json.animations ); + + } + + } + + for ( var i = 0; i < animations.length; i ++ ) { + + var clip = AnimationClip.parseAnimation( animations[ i ], geometry.bones ); + if ( clip ) outputAnimations.push( clip ); + + } + + // parse implicit morph animations + if ( geometry.morphTargets ) { + + // TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary. + var morphAnimationClips = AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 ); + outputAnimations = outputAnimations.concat( morphAnimationClips ); + + } + + if ( outputAnimations.length > 0 ) geometry.animations = outputAnimations; + + } + + return function ( json, texturePath ) { + + if ( json.data !== undefined ) { + + // Geometry 4.0 spec + json = json.data; + + } + + if ( json.scale !== undefined ) { + + json.scale = 1.0 / json.scale; + + } else { + + json.scale = 1.0; + + } + + var geometry = new Geometry(); + + parseModel( json, geometry ); + parseSkin( json, geometry ); + parseMorphing( json, geometry ); + parseAnimations( json, geometry ); + + geometry.computeFaceNormals(); + geometry.computeBoundingSphere(); + + if ( json.materials === undefined || json.materials.length === 0 ) { + + return { geometry: geometry }; + + } else { + + var materials = Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin ); + + return { geometry: geometry, materials: materials }; + + } + + }; + + } )() + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function ObjectLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + this.texturePath = ''; + + } + + Object.assign( ObjectLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + if ( this.texturePath === '' ) { + + this.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 ); + + } + + var scope = this; + + var loader = new FileLoader( scope.manager ); + loader.load( url, function ( text ) { + + var json = null; + + try { + + json = JSON.parse( text ); + + } catch ( error ) { + + if ( onError !== undefined ) onError( error ); + + console.error( 'THREE:ObjectLoader: Can\'t parse ' + url + '.', error.message ); + + return; + + } + + var metadata = json.metadata; + + if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) { + + console.error( 'THREE.ObjectLoader: Can\'t load ' + url + '. Use THREE.JSONLoader instead.' ); + return; + + } + + scope.parse( json, onLoad ); + + }, onProgress, onError ); + + }, + + setTexturePath: function ( value ) { + + this.texturePath = value; + + }, + + setCrossOrigin: function ( value ) { + + this.crossOrigin = value; + + }, + + parse: function ( json, onLoad ) { + + var shapes = this.parseShape( json.shapes ); + var geometries = this.parseGeometries( json.geometries, shapes ); + + var images = this.parseImages( json.images, function () { + + if ( onLoad !== undefined ) onLoad( object ); + + } ); + + var textures = this.parseTextures( json.textures, images ); + var materials = this.parseMaterials( json.materials, textures ); + + var object = this.parseObject( json.object, geometries, materials ); + + if ( json.animations ) { + + object.animations = this.parseAnimations( json.animations ); + + } + + if ( json.images === undefined || json.images.length === 0 ) { + + if ( onLoad !== undefined ) onLoad( object ); + + } + + return object; + + }, + + parseShape: function ( json ) { + + var shapes = {}; + + if ( json !== undefined ) { + + for ( var i = 0, l = json.length; i < l; i ++ ) { + + var shape = new Shape().fromJSON( json[ i ] ); + + shapes[ shape.uuid ] = shape; + + } + + } + + return shapes; + + }, + + parseGeometries: function ( json, shapes ) { + + var geometries = {}; + + if ( json !== undefined ) { + + var geometryLoader = new JSONLoader(); + var bufferGeometryLoader = new BufferGeometryLoader(); + + for ( var i = 0, l = json.length; i < l; i ++ ) { + + var geometry; + var data = json[ i ]; + + switch ( data.type ) { + + case 'PlaneGeometry': + case 'PlaneBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.width, + data.height, + data.widthSegments, + data.heightSegments + ); + + break; + + case 'BoxGeometry': + case 'BoxBufferGeometry': + case 'CubeGeometry': // backwards compatible + + geometry = new Geometries[ data.type ]( + data.width, + data.height, + data.depth, + data.widthSegments, + data.heightSegments, + data.depthSegments + ); + + break; + + case 'CircleGeometry': + case 'CircleBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.segments, + data.thetaStart, + data.thetaLength + ); + + break; + + case 'CylinderGeometry': + case 'CylinderBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radiusTop, + data.radiusBottom, + data.height, + data.radialSegments, + data.heightSegments, + data.openEnded, + data.thetaStart, + data.thetaLength + ); + + break; + + case 'ConeGeometry': + case 'ConeBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.height, + data.radialSegments, + data.heightSegments, + data.openEnded, + data.thetaStart, + data.thetaLength + ); + + break; + + case 'SphereGeometry': + case 'SphereBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.widthSegments, + data.heightSegments, + data.phiStart, + data.phiLength, + data.thetaStart, + data.thetaLength + ); + + break; + + case 'DodecahedronGeometry': + case 'DodecahedronBufferGeometry': + case 'IcosahedronGeometry': + case 'IcosahedronBufferGeometry': + case 'OctahedronGeometry': + case 'OctahedronBufferGeometry': + case 'TetrahedronGeometry': + case 'TetrahedronBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.detail + ); + + break; + + case 'RingGeometry': + case 'RingBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.innerRadius, + data.outerRadius, + data.thetaSegments, + data.phiSegments, + data.thetaStart, + data.thetaLength + ); + + break; + + case 'TorusGeometry': + case 'TorusBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.tube, + data.radialSegments, + data.tubularSegments, + data.arc + ); + + break; + + case 'TorusKnotGeometry': + case 'TorusKnotBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.radius, + data.tube, + data.tubularSegments, + data.radialSegments, + data.p, + data.q + ); + + break; + + case 'LatheGeometry': + case 'LatheBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.points, + data.segments, + data.phiStart, + data.phiLength + ); + + break; + + case 'PolyhedronGeometry': + case 'PolyhedronBufferGeometry': + + geometry = new Geometries[ data.type ]( + data.vertices, + data.indices, + data.radius, + data.details + ); + + break; + + case 'ShapeGeometry': + case 'ShapeBufferGeometry': + + var geometryShapes = []; + + for ( var i = 0, l = data.shapes.length; i < l; i ++ ) { + + var shape = shapes[ data.shapes[ i ] ]; + + geometryShapes.push( shape ); + + } + + geometry = new Geometries[ data.type ]( + geometryShapes, + data.curveSegments + ); + + break; + + case 'BufferGeometry': + + geometry = bufferGeometryLoader.parse( data ); + + break; + + case 'Geometry': + + geometry = geometryLoader.parse( data, this.texturePath ).geometry; + + break; + + default: + + console.warn( 'THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"' ); + + continue; + + } + + geometry.uuid = data.uuid; + + if ( data.name !== undefined ) geometry.name = data.name; + + geometries[ data.uuid ] = geometry; + + } + + } + + return geometries; + + }, + + parseMaterials: function ( json, textures ) { + + var materials = {}; + + if ( json !== undefined ) { + + var loader = new MaterialLoader(); + loader.setTextures( textures ); + + for ( var i = 0, l = json.length; i < l; i ++ ) { + + var data = json[ i ]; + + if ( data.type === 'MultiMaterial' ) { + + // Deprecated + + var array = []; + + for ( var j = 0; j < data.materials.length; j ++ ) { + + array.push( loader.parse( data.materials[ j ] ) ); + + } + + materials[ data.uuid ] = array; + + } else { + + materials[ data.uuid ] = loader.parse( data ); + + } + + } + + } + + return materials; + + }, + + parseAnimations: function ( json ) { + + var animations = []; + + for ( var i = 0; i < json.length; i ++ ) { + + var clip = AnimationClip.parse( json[ i ] ); + + animations.push( clip ); + + } + + return animations; + + }, + + parseImages: function ( json, onLoad ) { + + var scope = this; + var images = {}; + + function loadImage( url ) { + + scope.manager.itemStart( url ); + + return loader.load( url, function () { + + scope.manager.itemEnd( url ); + + }, undefined, function () { + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + } ); + + } + + if ( json !== undefined && json.length > 0 ) { + + var manager = new LoadingManager( onLoad ); + + var loader = new ImageLoader( manager ); + loader.setCrossOrigin( this.crossOrigin ); + + for ( var i = 0, l = json.length; i < l; i ++ ) { + + var image = json[ i ]; + var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url; + + images[ image.uuid ] = loadImage( path ); + + } + + } + + return images; + + }, + + parseTextures: function ( json, images ) { + + function parseConstant( value, type ) { + + if ( typeof value === 'number' ) return value; + + console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value ); + + return type[ value ]; + + } + + var textures = {}; + + if ( json !== undefined ) { + + for ( var i = 0, l = json.length; i < l; i ++ ) { + + var data = json[ i ]; + + if ( data.image === undefined ) { + + console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid ); + + } + + if ( images[ data.image ] === undefined ) { + + console.warn( 'THREE.ObjectLoader: Undefined image', data.image ); + + } + + var texture = new Texture( images[ data.image ] ); + texture.needsUpdate = true; + + texture.uuid = data.uuid; + + if ( data.name !== undefined ) texture.name = data.name; + + if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING ); + + if ( data.offset !== undefined ) texture.offset.fromArray( data.offset ); + if ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat ); + if ( data.center !== undefined ) texture.center.fromArray( data.center ); + if ( data.rotation !== undefined ) texture.rotation = data.rotation; + + if ( data.wrap !== undefined ) { + + texture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING ); + texture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING ); + + } + + if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER ); + if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER ); + if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy; + + if ( data.flipY !== undefined ) texture.flipY = data.flipY; + + textures[ data.uuid ] = texture; + + } + + } + + return textures; + + }, + + parseObject: function () { + + var matrix = new Matrix4(); + + return function parseObject( data, geometries, materials ) { + + var object; + + function getGeometry( name ) { + + if ( geometries[ name ] === undefined ) { + + console.warn( 'THREE.ObjectLoader: Undefined geometry', name ); + + } + + return geometries[ name ]; + + } + + function getMaterial( name ) { + + if ( name === undefined ) return undefined; + + if ( Array.isArray( name ) ) { + + var array = []; + + for ( var i = 0, l = name.length; i < l; i ++ ) { + + var uuid = name[ i ]; + + if ( materials[ uuid ] === undefined ) { + + console.warn( 'THREE.ObjectLoader: Undefined material', uuid ); + + } + + array.push( materials[ uuid ] ); + + } + + return array; + + } + + if ( materials[ name ] === undefined ) { + + console.warn( 'THREE.ObjectLoader: Undefined material', name ); + + } + + return materials[ name ]; + + } + + switch ( data.type ) { + + case 'Scene': + + object = new Scene(); + + if ( data.background !== undefined ) { + + if ( Number.isInteger( data.background ) ) { + + object.background = new Color( data.background ); + + } + + } + + if ( data.fog !== undefined ) { + + if ( data.fog.type === 'Fog' ) { + + object.fog = new Fog( data.fog.color, data.fog.near, data.fog.far ); + + } else if ( data.fog.type === 'FogExp2' ) { + + object.fog = new FogExp2( data.fog.color, data.fog.density ); + + } + + } + + break; + + case 'PerspectiveCamera': + + object = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far ); + + if ( data.focus !== undefined ) object.focus = data.focus; + if ( data.zoom !== undefined ) object.zoom = data.zoom; + if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge; + if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset; + if ( data.view !== undefined ) object.view = Object.assign( {}, data.view ); + + break; + + case 'OrthographicCamera': + + object = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far ); + + break; + + case 'AmbientLight': + + object = new AmbientLight( data.color, data.intensity ); + + break; + + case 'DirectionalLight': + + object = new DirectionalLight( data.color, data.intensity ); + + break; + + case 'PointLight': + + object = new PointLight( data.color, data.intensity, data.distance, data.decay ); + + break; + + case 'RectAreaLight': + + object = new RectAreaLight( data.color, data.intensity, data.width, data.height ); + + break; + + case 'SpotLight': + + object = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay ); + + break; + + case 'HemisphereLight': + + object = new HemisphereLight( data.color, data.groundColor, data.intensity ); + + break; + + case 'SkinnedMesh': + + console.warn( 'THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.' ); + + case 'Mesh': + + var geometry = getGeometry( data.geometry ); + var material = getMaterial( data.material ); + + if ( geometry.bones && geometry.bones.length > 0 ) { + + object = new SkinnedMesh( geometry, material ); + + } else { + + object = new Mesh( geometry, material ); + + } + + break; + + case 'LOD': + + object = new LOD(); + + break; + + case 'Line': + + object = new Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode ); + + break; + + case 'LineLoop': + + object = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) ); + + break; + + case 'LineSegments': + + object = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) ); + + break; + + case 'PointCloud': + case 'Points': + + object = new Points( getGeometry( data.geometry ), getMaterial( data.material ) ); + + break; + + case 'Sprite': + + object = new Sprite( getMaterial( data.material ) ); + + break; + + case 'Group': + + object = new Group(); + + break; + + default: + + object = new Object3D(); + + } + + object.uuid = data.uuid; + + if ( data.name !== undefined ) object.name = data.name; + if ( data.matrix !== undefined ) { + + matrix.fromArray( data.matrix ); + matrix.decompose( object.position, object.quaternion, object.scale ); + + } else { + + if ( data.position !== undefined ) object.position.fromArray( data.position ); + if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation ); + if ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion ); + if ( data.scale !== undefined ) object.scale.fromArray( data.scale ); + + } + + if ( data.castShadow !== undefined ) object.castShadow = data.castShadow; + if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow; + + if ( data.shadow ) { + + if ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias; + if ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius; + if ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize ); + if ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera ); + + } + + if ( data.visible !== undefined ) object.visible = data.visible; + if ( data.userData !== undefined ) object.userData = data.userData; + + if ( data.children !== undefined ) { + + var children = data.children; + + for ( var i = 0; i < children.length; i ++ ) { + + object.add( this.parseObject( children[ i ], geometries, materials ) ); + + } + + } + + if ( data.type === 'LOD' ) { + + var levels = data.levels; + + for ( var l = 0; l < levels.length; l ++ ) { + + var level = levels[ l ]; + var child = object.getObjectByProperty( 'uuid', level.object ); + + if ( child !== undefined ) { + + object.addLevel( child, level.distance ); + + } + + } + + } + + return object; + + }; + + }() + + } ); + + var TEXTURE_MAPPING = { + UVMapping: UVMapping, + CubeReflectionMapping: CubeReflectionMapping, + CubeRefractionMapping: CubeRefractionMapping, + EquirectangularReflectionMapping: EquirectangularReflectionMapping, + EquirectangularRefractionMapping: EquirectangularRefractionMapping, + SphericalReflectionMapping: SphericalReflectionMapping, + CubeUVReflectionMapping: CubeUVReflectionMapping, + CubeUVRefractionMapping: CubeUVRefractionMapping + }; + + var TEXTURE_WRAPPING = { + RepeatWrapping: RepeatWrapping, + ClampToEdgeWrapping: ClampToEdgeWrapping, + MirroredRepeatWrapping: MirroredRepeatWrapping + }; + + var TEXTURE_FILTER = { + NearestFilter: NearestFilter, + NearestMipMapNearestFilter: NearestMipMapNearestFilter, + NearestMipMapLinearFilter: NearestMipMapLinearFilter, + LinearFilter: LinearFilter, + LinearMipMapNearestFilter: LinearMipMapNearestFilter, + LinearMipMapLinearFilter: LinearMipMapLinearFilter + }; + + /** + * @author thespite / http://clicktorelease.com/ + */ + + function ImageBitmapLoader( manager ) { + + if ( typeof createImageBitmap === 'undefined' ) { + + console.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' ); + + } + + if ( typeof fetch === 'undefined' ) { + + console.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' ); + + } + + this.manager = manager !== undefined ? manager : DefaultLoadingManager; + this.options = undefined; + + } + + ImageBitmapLoader.prototype = { + + constructor: ImageBitmapLoader, + + setOptions: function setOptions( options ) { + + this.options = options; + + return this; + + }, + + load: function load( url, onLoad, onProgress, onError ) { + + if ( url === undefined ) url = ''; + + if ( this.path !== undefined ) url = this.path + url; + + var scope = this; + + var cached = Cache.get( url ); + + if ( cached !== undefined ) { + + scope.manager.itemStart( url ); + + setTimeout( function () { + + if ( onLoad ) onLoad( cached ); + + scope.manager.itemEnd( url ); + + }, 0 ); + + return cached; + + } + + fetch( url ).then( function ( res ) { + + return res.blob(); + + } ).then( function ( blob ) { + + return createImageBitmap( blob, scope.options ); + + } ).then( function ( imageBitmap ) { + + Cache.add( url, imageBitmap ); + + if ( onLoad ) onLoad( imageBitmap ); + + scope.manager.itemEnd( url ); + + } ).catch( function ( e ) { + + if ( onError ) onError( e ); + + scope.manager.itemEnd( url ); + scope.manager.itemError( url ); + + } ); + + }, + + setCrossOrigin: function ( /* value */ ) { + + return this; + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + }; + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * minimal class for proxing functions to Path. Replaces old "extractSubpaths()" + **/ + + function ShapePath() { + + this.type = 'ShapePath'; + + this.subPaths = []; + this.currentPath = null; + + } + + Object.assign( ShapePath.prototype, { + + moveTo: function ( x, y ) { + + this.currentPath = new Path(); + this.subPaths.push( this.currentPath ); + this.currentPath.moveTo( x, y ); + + }, + + lineTo: function ( x, y ) { + + this.currentPath.lineTo( x, y ); + + }, + + quadraticCurveTo: function ( aCPx, aCPy, aX, aY ) { + + this.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY ); + + }, + + bezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) { + + this.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ); + + }, + + splineThru: function ( pts ) { + + this.currentPath.splineThru( pts ); + + }, + + toShapes: function ( isCCW, noHoles ) { + + function toShapesNoHoles( inSubpaths ) { + + var shapes = []; + + for ( var i = 0, l = inSubpaths.length; i < l; i ++ ) { + + var tmpPath = inSubpaths[ i ]; + + var tmpShape = new Shape(); + tmpShape.curves = tmpPath.curves; + + shapes.push( tmpShape ); + + } + + return shapes; + + } + + function isPointInsidePolygon( inPt, inPolygon ) { + + var polyLen = inPolygon.length; + + // inPt on polygon contour => immediate success or + // toggling of inside/outside at every single! intersection point of an edge + // with the horizontal line through inPt, left of inPt + // not counting lowerY endpoints of edges and whole edges on that line + var inside = false; + for ( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) { + + var edgeLowPt = inPolygon[ p ]; + var edgeHighPt = inPolygon[ q ]; + + var edgeDx = edgeHighPt.x - edgeLowPt.x; + var edgeDy = edgeHighPt.y - edgeLowPt.y; + + if ( Math.abs( edgeDy ) > Number.EPSILON ) { + + // not parallel + if ( edgeDy < 0 ) { + + edgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx; + edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy; + + } + if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) continue; + + if ( inPt.y === edgeLowPt.y ) { + + if ( inPt.x === edgeLowPt.x ) return true; // inPt is on contour ? + // continue; // no intersection or edgeLowPt => doesn't count !!! + + } else { + + var perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y ); + if ( perpEdge === 0 ) return true; // inPt is on contour ? + if ( perpEdge < 0 ) continue; + inside = ! inside; // true intersection left of inPt + + } + + } else { + + // parallel or collinear + if ( inPt.y !== edgeLowPt.y ) continue; // parallel + // edge lies on the same horizontal line as inPt + if ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) || + ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) ) return true; // inPt: Point on contour ! + // continue; + + } + + } + + return inside; + + } + + var isClockWise = ShapeUtils.isClockWise; + + var subPaths = this.subPaths; + if ( subPaths.length === 0 ) return []; + + if ( noHoles === true ) return toShapesNoHoles( subPaths ); + + + var solid, tmpPath, tmpShape, shapes = []; + + if ( subPaths.length === 1 ) { + + tmpPath = subPaths[ 0 ]; + tmpShape = new Shape(); + tmpShape.curves = tmpPath.curves; + shapes.push( tmpShape ); + return shapes; + + } + + var holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() ); + holesFirst = isCCW ? ! holesFirst : holesFirst; + + // console.log("Holes first", holesFirst); + + var betterShapeHoles = []; + var newShapes = []; + var newShapeHoles = []; + var mainIdx = 0; + var tmpPoints; + + newShapes[ mainIdx ] = undefined; + newShapeHoles[ mainIdx ] = []; + + for ( var i = 0, l = subPaths.length; i < l; i ++ ) { + + tmpPath = subPaths[ i ]; + tmpPoints = tmpPath.getPoints(); + solid = isClockWise( tmpPoints ); + solid = isCCW ? ! solid : solid; + + if ( solid ) { + + if ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) ) mainIdx ++; + + newShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints }; + newShapes[ mainIdx ].s.curves = tmpPath.curves; + + if ( holesFirst ) mainIdx ++; + newShapeHoles[ mainIdx ] = []; + + //console.log('cw', i); + + } else { + + newShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } ); + + //console.log('ccw', i); + + } + + } + + // only Holes? -> probably all Shapes with wrong orientation + if ( ! newShapes[ 0 ] ) return toShapesNoHoles( subPaths ); + + + if ( newShapes.length > 1 ) { + + var ambiguous = false; + var toChange = []; + + for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) { + + betterShapeHoles[ sIdx ] = []; + + } + + for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) { + + var sho = newShapeHoles[ sIdx ]; + + for ( var hIdx = 0; hIdx < sho.length; hIdx ++ ) { + + var ho = sho[ hIdx ]; + var hole_unassigned = true; + + for ( var s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) { + + if ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) { + + if ( sIdx !== s2Idx ) toChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } ); + if ( hole_unassigned ) { + + hole_unassigned = false; + betterShapeHoles[ s2Idx ].push( ho ); + + } else { + + ambiguous = true; + + } + + } + + } + if ( hole_unassigned ) { + + betterShapeHoles[ sIdx ].push( ho ); + + } + + } + + } + // console.log("ambiguous: ", ambiguous); + if ( toChange.length > 0 ) { + + // console.log("to change: ", toChange); + if ( ! ambiguous ) newShapeHoles = betterShapeHoles; + + } + + } + + var tmpHoles; + + for ( var i = 0, il = newShapes.length; i < il; i ++ ) { + + tmpShape = newShapes[ i ].s; + shapes.push( tmpShape ); + tmpHoles = newShapeHoles[ i ]; + + for ( var j = 0, jl = tmpHoles.length; j < jl; j ++ ) { + + tmpShape.holes.push( tmpHoles[ j ].h ); + + } + + } + + //console.log("shape", shapes); + + return shapes; + + } + + } ); + + /** + * @author zz85 / http://www.lab4games.net/zz85/blog + * @author mrdoob / http://mrdoob.com/ + */ + + function Font( data ) { + + this.type = 'Font'; + + this.data = data; + + } + + Object.assign( Font.prototype, { + + isFont: true, + + generateShapes: function ( text, size, divisions ) { + + function createPaths( text ) { + + var chars = String( text ).split( '' ); + var scale = size / data.resolution; + var line_height = ( data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness ) * scale; + + var offsetX = 0, offsetY = 0; + + var paths = []; + + for ( var i = 0; i < chars.length; i ++ ) { + + var char = chars[ i ]; + + if ( char === '\n' ) { + + offsetX = 0; + offsetY -= line_height; + + } else { + + var ret = createPath( char, scale, offsetX, offsetY ); + offsetX += ret.offsetX; + paths.push( ret.path ); + + } + + } + + return paths; + + } + + function createPath( c, scale, offsetX, offsetY ) { + + var glyph = data.glyphs[ c ] || data.glyphs[ '?' ]; + + if ( ! glyph ) return; + + var path = new ShapePath(); + + var pts = []; + var x, y, cpx, cpy, cpx0, cpy0, cpx1, cpy1, cpx2, cpy2, laste; + + if ( glyph.o ) { + + var outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) ); + + for ( var i = 0, l = outline.length; i < l; ) { + + var action = outline[ i ++ ]; + + switch ( action ) { + + case 'm': // moveTo + + x = outline[ i ++ ] * scale + offsetX; + y = outline[ i ++ ] * scale + offsetY; + + path.moveTo( x, y ); + + break; + + case 'l': // lineTo + + x = outline[ i ++ ] * scale + offsetX; + y = outline[ i ++ ] * scale + offsetY; + + path.lineTo( x, y ); + + break; + + case 'q': // quadraticCurveTo + + cpx = outline[ i ++ ] * scale + offsetX; + cpy = outline[ i ++ ] * scale + offsetY; + cpx1 = outline[ i ++ ] * scale + offsetX; + cpy1 = outline[ i ++ ] * scale + offsetY; + + path.quadraticCurveTo( cpx1, cpy1, cpx, cpy ); + + laste = pts[ pts.length - 1 ]; + + if ( laste ) { + + cpx0 = laste.x; + cpy0 = laste.y; + + + + } + + break; + + case 'b': // bezierCurveTo + + cpx = outline[ i ++ ] * scale + offsetX; + cpy = outline[ i ++ ] * scale + offsetY; + cpx1 = outline[ i ++ ] * scale + offsetX; + cpy1 = outline[ i ++ ] * scale + offsetY; + cpx2 = outline[ i ++ ] * scale + offsetX; + cpy2 = outline[ i ++ ] * scale + offsetY; + + path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy ); + + laste = pts[ pts.length - 1 ]; + + if ( laste ) { + + cpx0 = laste.x; + cpy0 = laste.y; + + + + } + + break; + + } + + } + + } + + return { offsetX: glyph.ha * scale, path: path }; + + } + + // + + if ( size === undefined ) size = 100; + if ( divisions === undefined ) divisions = 4; + + var data = this.data; + + var paths = createPaths( text ); + var shapes = []; + + for ( var p = 0, pl = paths.length; p < pl; p ++ ) { + + Array.prototype.push.apply( shapes, paths[ p ].toShapes() ); + + } + + return shapes; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function FontLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( FontLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var loader = new FileLoader( this.manager ); + loader.setPath( this.path ); + loader.load( url, function ( text ) { + + var json; + + try { + + json = JSON.parse( text ); + + } catch ( e ) { + + console.warn( 'THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.' ); + json = JSON.parse( text.substring( 65, text.length - 2 ) ); + + } + + var font = scope.parse( json ); + + if ( onLoad ) onLoad( font ); + + }, onProgress, onError ); + + }, + + parse: function ( json ) { + + return new Font( json ); + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + var context; + + var AudioContext = { + + getContext: function () { + + if ( context === undefined ) { + + context = new ( window.AudioContext || window.webkitAudioContext )(); + + } + + return context; + + }, + + setContext: function ( value ) { + + context = value; + + } + + }; + + /** + * @author Reece Aaron Lecrivain / http://reecenotes.com/ + */ + + function AudioLoader( manager ) { + + this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager; + + } + + Object.assign( AudioLoader.prototype, { + + load: function ( url, onLoad, onProgress, onError ) { + + var loader = new FileLoader( this.manager ); + loader.setResponseType( 'arraybuffer' ); + loader.load( url, function ( buffer ) { + + var context = AudioContext.getContext(); + + context.decodeAudioData( buffer, function ( audioBuffer ) { + + onLoad( audioBuffer ); + + } ); + + }, onProgress, onError ); + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function StereoCamera() { + + this.type = 'StereoCamera'; + + this.aspect = 1; + + this.eyeSep = 0.064; + + this.cameraL = new PerspectiveCamera(); + this.cameraL.layers.enable( 1 ); + this.cameraL.matrixAutoUpdate = false; + + this.cameraR = new PerspectiveCamera(); + this.cameraR.layers.enable( 2 ); + this.cameraR.matrixAutoUpdate = false; + + } + + Object.assign( StereoCamera.prototype, { + + update: ( function () { + + var instance, focus, fov, aspect, near, far, zoom, eyeSep; + + var eyeRight = new Matrix4(); + var eyeLeft = new Matrix4(); + + return function update( camera ) { + + var needsUpdate = instance !== this || focus !== camera.focus || fov !== camera.fov || + aspect !== camera.aspect * this.aspect || near !== camera.near || + far !== camera.far || zoom !== camera.zoom || eyeSep !== this.eyeSep; + + if ( needsUpdate ) { + + instance = this; + focus = camera.focus; + fov = camera.fov; + aspect = camera.aspect * this.aspect; + near = camera.near; + far = camera.far; + zoom = camera.zoom; + + // Off-axis stereoscopic effect based on + // http://paulbourke.net/stereographics/stereorender/ + + var projectionMatrix = camera.projectionMatrix.clone(); + eyeSep = this.eyeSep / 2; + var eyeSepOnProjection = eyeSep * near / focus; + var ymax = ( near * Math.tan( _Math.DEG2RAD * fov * 0.5 ) ) / zoom; + var xmin, xmax; + + // translate xOffset + + eyeLeft.elements[ 12 ] = - eyeSep; + eyeRight.elements[ 12 ] = eyeSep; + + // for left eye + + xmin = - ymax * aspect + eyeSepOnProjection; + xmax = ymax * aspect + eyeSepOnProjection; + + projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin ); + projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin ); + + this.cameraL.projectionMatrix.copy( projectionMatrix ); + + // for right eye + + xmin = - ymax * aspect - eyeSepOnProjection; + xmax = ymax * aspect - eyeSepOnProjection; + + projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin ); + projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin ); + + this.cameraR.projectionMatrix.copy( projectionMatrix ); + + } + + this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft ); + this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight ); + + }; + + } )() + + } ); + + /** + * Camera for rendering cube maps + * - renders scene into axis-aligned cube + * + * @author alteredq / http://alteredqualia.com/ + */ + + function CubeCamera( near, far, cubeResolution ) { + + Object3D.call( this ); + + this.type = 'CubeCamera'; + + var fov = 90, aspect = 1; + + var cameraPX = new PerspectiveCamera( fov, aspect, near, far ); + cameraPX.up.set( 0, - 1, 0 ); + cameraPX.lookAt( new Vector3( 1, 0, 0 ) ); + this.add( cameraPX ); + + var cameraNX = new PerspectiveCamera( fov, aspect, near, far ); + cameraNX.up.set( 0, - 1, 0 ); + cameraNX.lookAt( new Vector3( - 1, 0, 0 ) ); + this.add( cameraNX ); + + var cameraPY = new PerspectiveCamera( fov, aspect, near, far ); + cameraPY.up.set( 0, 0, 1 ); + cameraPY.lookAt( new Vector3( 0, 1, 0 ) ); + this.add( cameraPY ); + + var cameraNY = new PerspectiveCamera( fov, aspect, near, far ); + cameraNY.up.set( 0, 0, - 1 ); + cameraNY.lookAt( new Vector3( 0, - 1, 0 ) ); + this.add( cameraNY ); + + var cameraPZ = new PerspectiveCamera( fov, aspect, near, far ); + cameraPZ.up.set( 0, - 1, 0 ); + cameraPZ.lookAt( new Vector3( 0, 0, 1 ) ); + this.add( cameraPZ ); + + var cameraNZ = new PerspectiveCamera( fov, aspect, near, far ); + cameraNZ.up.set( 0, - 1, 0 ); + cameraNZ.lookAt( new Vector3( 0, 0, - 1 ) ); + this.add( cameraNZ ); + + var options = { format: RGBFormat, magFilter: LinearFilter, minFilter: LinearFilter }; + + this.renderTarget = new WebGLRenderTargetCube( cubeResolution, cubeResolution, options ); + this.renderTarget.texture.name = "CubeCamera"; + + this.update = function ( renderer, scene ) { + + if ( this.parent === null ) this.updateMatrixWorld(); + + var renderTarget = this.renderTarget; + var generateMipmaps = renderTarget.texture.generateMipmaps; + + renderTarget.texture.generateMipmaps = false; + + renderTarget.activeCubeFace = 0; + renderer.render( scene, cameraPX, renderTarget ); + + renderTarget.activeCubeFace = 1; + renderer.render( scene, cameraNX, renderTarget ); + + renderTarget.activeCubeFace = 2; + renderer.render( scene, cameraPY, renderTarget ); + + renderTarget.activeCubeFace = 3; + renderer.render( scene, cameraNY, renderTarget ); + + renderTarget.activeCubeFace = 4; + renderer.render( scene, cameraPZ, renderTarget ); + + renderTarget.texture.generateMipmaps = generateMipmaps; + + renderTarget.activeCubeFace = 5; + renderer.render( scene, cameraNZ, renderTarget ); + + renderer.setRenderTarget( null ); + + }; + + this.clear = function ( renderer, color, depth, stencil ) { + + var renderTarget = this.renderTarget; + + for ( var i = 0; i < 6; i ++ ) { + + renderTarget.activeCubeFace = i; + renderer.setRenderTarget( renderTarget ); + + renderer.clear( color, depth, stencil ); + + } + + renderer.setRenderTarget( null ); + + }; + + } + + CubeCamera.prototype = Object.create( Object3D.prototype ); + CubeCamera.prototype.constructor = CubeCamera; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function AudioListener() { + + Object3D.call( this ); + + this.type = 'AudioListener'; + + this.context = AudioContext.getContext(); + + this.gain = this.context.createGain(); + this.gain.connect( this.context.destination ); + + this.filter = null; + + } + + AudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: AudioListener, + + getInput: function () { + + return this.gain; + + }, + + removeFilter: function ( ) { + + if ( this.filter !== null ) { + + this.gain.disconnect( this.filter ); + this.filter.disconnect( this.context.destination ); + this.gain.connect( this.context.destination ); + this.filter = null; + + } + + }, + + getFilter: function () { + + return this.filter; + + }, + + setFilter: function ( value ) { + + if ( this.filter !== null ) { + + this.gain.disconnect( this.filter ); + this.filter.disconnect( this.context.destination ); + + } else { + + this.gain.disconnect( this.context.destination ); + + } + + this.filter = value; + this.gain.connect( this.filter ); + this.filter.connect( this.context.destination ); + + }, + + getMasterVolume: function () { + + return this.gain.gain.value; + + }, + + setMasterVolume: function ( value ) { + + this.gain.gain.value = value; + + }, + + updateMatrixWorld: ( function () { + + var position = new Vector3(); + var quaternion = new Quaternion(); + var scale = new Vector3(); + + var orientation = new Vector3(); + + return function updateMatrixWorld( force ) { + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + var listener = this.context.listener; + var up = this.up; + + this.matrixWorld.decompose( position, quaternion, scale ); + + orientation.set( 0, 0, - 1 ).applyQuaternion( quaternion ); + + if ( listener.positionX ) { + + listener.positionX.setValueAtTime( position.x, this.context.currentTime ); + listener.positionY.setValueAtTime( position.y, this.context.currentTime ); + listener.positionZ.setValueAtTime( position.z, this.context.currentTime ); + listener.forwardX.setValueAtTime( orientation.x, this.context.currentTime ); + listener.forwardY.setValueAtTime( orientation.y, this.context.currentTime ); + listener.forwardZ.setValueAtTime( orientation.z, this.context.currentTime ); + listener.upX.setValueAtTime( up.x, this.context.currentTime ); + listener.upY.setValueAtTime( up.y, this.context.currentTime ); + listener.upZ.setValueAtTime( up.z, this.context.currentTime ); + + } else { + + listener.setPosition( position.x, position.y, position.z ); + listener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z ); + + } + + }; + + } )() + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Reece Aaron Lecrivain / http://reecenotes.com/ + */ + + function Audio( listener ) { + + Object3D.call( this ); + + this.type = 'Audio'; + + this.context = listener.context; + + this.gain = this.context.createGain(); + this.gain.connect( listener.getInput() ); + + this.autoplay = false; + + this.buffer = null; + this.loop = false; + this.startTime = 0; + this.offset = 0; + this.playbackRate = 1; + this.isPlaying = false; + this.hasPlaybackControl = true; + this.sourceType = 'empty'; + + this.filters = []; + + } + + Audio.prototype = Object.assign( Object.create( Object3D.prototype ), { + + constructor: Audio, + + getOutput: function () { + + return this.gain; + + }, + + setNodeSource: function ( audioNode ) { + + this.hasPlaybackControl = false; + this.sourceType = 'audioNode'; + this.source = audioNode; + this.connect(); + + return this; + + }, + + setBuffer: function ( audioBuffer ) { + + this.buffer = audioBuffer; + this.sourceType = 'buffer'; + + if ( this.autoplay ) this.play(); + + return this; + + }, + + play: function () { + + if ( this.isPlaying === true ) { + + console.warn( 'THREE.Audio: Audio is already playing.' ); + return; + + } + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return; + + } + + var source = this.context.createBufferSource(); + + source.buffer = this.buffer; + source.loop = this.loop; + source.onended = this.onEnded.bind( this ); + source.playbackRate.setValueAtTime( this.playbackRate, this.startTime ); + this.startTime = this.context.currentTime; + source.start( this.startTime, this.offset ); + + this.isPlaying = true; + + this.source = source; + + return this.connect(); + + }, + + pause: function () { + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return; + + } + + if ( this.isPlaying === true ) { + + this.source.stop(); + this.offset += ( this.context.currentTime - this.startTime ) * this.playbackRate; + this.isPlaying = false; + + } + + return this; + + }, + + stop: function () { + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return; + + } + + this.source.stop(); + this.offset = 0; + this.isPlaying = false; + + return this; + + }, + + connect: function () { + + if ( this.filters.length > 0 ) { + + this.source.connect( this.filters[ 0 ] ); + + for ( var i = 1, l = this.filters.length; i < l; i ++ ) { + + this.filters[ i - 1 ].connect( this.filters[ i ] ); + + } + + this.filters[ this.filters.length - 1 ].connect( this.getOutput() ); + + } else { + + this.source.connect( this.getOutput() ); + + } + + return this; + + }, + + disconnect: function () { + + if ( this.filters.length > 0 ) { + + this.source.disconnect( this.filters[ 0 ] ); + + for ( var i = 1, l = this.filters.length; i < l; i ++ ) { + + this.filters[ i - 1 ].disconnect( this.filters[ i ] ); + + } + + this.filters[ this.filters.length - 1 ].disconnect( this.getOutput() ); + + } else { + + this.source.disconnect( this.getOutput() ); + + } + + return this; + + }, + + getFilters: function () { + + return this.filters; + + }, + + setFilters: function ( value ) { + + if ( ! value ) value = []; + + if ( this.isPlaying === true ) { + + this.disconnect(); + this.filters = value; + this.connect(); + + } else { + + this.filters = value; + + } + + return this; + + }, + + getFilter: function () { + + return this.getFilters()[ 0 ]; + + }, + + setFilter: function ( filter ) { + + return this.setFilters( filter ? [ filter ] : [] ); + + }, + + setPlaybackRate: function ( value ) { + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return; + + } + + this.playbackRate = value; + + if ( this.isPlaying === true ) { + + this.source.playbackRate.setValueAtTime( this.playbackRate, this.context.currentTime ); + + } + + return this; + + }, + + getPlaybackRate: function () { + + return this.playbackRate; + + }, + + onEnded: function () { + + this.isPlaying = false; + + }, + + getLoop: function () { + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return false; + + } + + return this.loop; + + }, + + setLoop: function ( value ) { + + if ( this.hasPlaybackControl === false ) { + + console.warn( 'THREE.Audio: this Audio has no playback control.' ); + return; + + } + + this.loop = value; + + if ( this.isPlaying === true ) { + + this.source.loop = this.loop; + + } + + return this; + + }, + + getVolume: function () { + + return this.gain.gain.value; + + }, + + setVolume: function ( value ) { + + this.gain.gain.value = value; + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function PositionalAudio( listener ) { + + Audio.call( this, listener ); + + this.panner = this.context.createPanner(); + this.panner.connect( this.gain ); + + } + + PositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), { + + constructor: PositionalAudio, + + getOutput: function () { + + return this.panner; + + }, + + getRefDistance: function () { + + return this.panner.refDistance; + + }, + + setRefDistance: function ( value ) { + + this.panner.refDistance = value; + + }, + + getRolloffFactor: function () { + + return this.panner.rolloffFactor; + + }, + + setRolloffFactor: function ( value ) { + + this.panner.rolloffFactor = value; + + }, + + getDistanceModel: function () { + + return this.panner.distanceModel; + + }, + + setDistanceModel: function ( value ) { + + this.panner.distanceModel = value; + + }, + + getMaxDistance: function () { + + return this.panner.maxDistance; + + }, + + setMaxDistance: function ( value ) { + + this.panner.maxDistance = value; + + }, + + updateMatrixWorld: ( function () { + + var position = new Vector3(); + + return function updateMatrixWorld( force ) { + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + position.setFromMatrixPosition( this.matrixWorld ); + + this.panner.setPosition( position.x, position.y, position.z ); + + }; + + } )() + + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function AudioAnalyser( audio, fftSize ) { + + this.analyser = audio.context.createAnalyser(); + this.analyser.fftSize = fftSize !== undefined ? fftSize : 2048; + + this.data = new Uint8Array( this.analyser.frequencyBinCount ); + + audio.getOutput().connect( this.analyser ); + + } + + Object.assign( AudioAnalyser.prototype, { + + getFrequencyData: function () { + + this.analyser.getByteFrequencyData( this.data ); + + return this.data; + + }, + + getAverageFrequency: function () { + + var value = 0, data = this.getFrequencyData(); + + for ( var i = 0; i < data.length; i ++ ) { + + value += data[ i ]; + + } + + return value / data.length; + + } + + } ); + + /** + * + * Buffered scene graph property that allows weighted accumulation. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function PropertyMixer( binding, typeName, valueSize ) { + + this.binding = binding; + this.valueSize = valueSize; + + var bufferType = Float64Array, + mixFunction; + + switch ( typeName ) { + + case 'quaternion': + mixFunction = this._slerp; + break; + + case 'string': + case 'bool': + bufferType = Array; + mixFunction = this._select; + break; + + default: + mixFunction = this._lerp; + + } + + this.buffer = new bufferType( valueSize * 4 ); + // layout: [ incoming | accu0 | accu1 | orig ] + // + // interpolators can use .buffer as their .result + // the data then goes to 'incoming' + // + // 'accu0' and 'accu1' are used frame-interleaved for + // the cumulative result and are compared to detect + // changes + // + // 'orig' stores the original state of the property + + this._mixBufferRegion = mixFunction; + + this.cumulativeWeight = 0; + + this.useCount = 0; + this.referenceCount = 0; + + } + + Object.assign( PropertyMixer.prototype, { + + // accumulate data in the 'incoming' region into 'accu' + accumulate: function ( accuIndex, weight ) { + + // note: happily accumulating nothing when weight = 0, the caller knows + // the weight and shouldn't have made the call in the first place + + var buffer = this.buffer, + stride = this.valueSize, + offset = accuIndex * stride + stride, + + currentWeight = this.cumulativeWeight; + + if ( currentWeight === 0 ) { + + // accuN := incoming * weight + + for ( var i = 0; i !== stride; ++ i ) { + + buffer[ offset + i ] = buffer[ i ]; + + } + + currentWeight = weight; + + } else { + + // accuN := accuN + incoming * weight + + currentWeight += weight; + var mix = weight / currentWeight; + this._mixBufferRegion( buffer, offset, 0, mix, stride ); + + } + + this.cumulativeWeight = currentWeight; + + }, + + // apply the state of 'accu' to the binding when accus differ + apply: function ( accuIndex ) { + + var stride = this.valueSize, + buffer = this.buffer, + offset = accuIndex * stride + stride, + + weight = this.cumulativeWeight, + + binding = this.binding; + + this.cumulativeWeight = 0; + + if ( weight < 1 ) { + + // accuN := accuN + original * ( 1 - cumulativeWeight ) + + var originalValueOffset = stride * 3; + + this._mixBufferRegion( + buffer, offset, originalValueOffset, 1 - weight, stride ); + + } + + for ( var i = stride, e = stride + stride; i !== e; ++ i ) { + + if ( buffer[ i ] !== buffer[ i + stride ] ) { + + // value has changed -> update scene graph + + binding.setValue( buffer, offset ); + break; + + } + + } + + }, + + // remember the state of the bound property and copy it to both accus + saveOriginalState: function () { + + var binding = this.binding; + + var buffer = this.buffer, + stride = this.valueSize, + + originalValueOffset = stride * 3; + + binding.getValue( buffer, originalValueOffset ); + + // accu[0..1] := orig -- initially detect changes against the original + for ( var i = stride, e = originalValueOffset; i !== e; ++ i ) { + + buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ]; + + } + + this.cumulativeWeight = 0; + + }, + + // apply the state previously taken via 'saveOriginalState' to the binding + restoreOriginalState: function () { + + var originalValueOffset = this.valueSize * 3; + this.binding.setValue( this.buffer, originalValueOffset ); + + }, + + + // mix functions + + _select: function ( buffer, dstOffset, srcOffset, t, stride ) { + + if ( t >= 0.5 ) { + + for ( var i = 0; i !== stride; ++ i ) { + + buffer[ dstOffset + i ] = buffer[ srcOffset + i ]; + + } + + } + + }, + + _slerp: function ( buffer, dstOffset, srcOffset, t ) { + + Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t ); + + }, + + _lerp: function ( buffer, dstOffset, srcOffset, t, stride ) { + + var s = 1 - t; + + for ( var i = 0; i !== stride; ++ i ) { + + var j = dstOffset + i; + + buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t; + + } + + } + + } ); + + /** + * + * A reference to a real property in the scene graph. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function Composite( targetGroup, path, optionalParsedPath ) { + + var parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path ); + + this._targetGroup = targetGroup; + this._bindings = targetGroup.subscribe_( path, parsedPath ); + + } + + Object.assign( Composite.prototype, { + + getValue: function ( array, offset ) { + + this.bind(); // bind all binding + + var firstValidIndex = this._targetGroup.nCachedObjects_, + binding = this._bindings[ firstValidIndex ]; + + // and only call .getValue on the first + if ( binding !== undefined ) binding.getValue( array, offset ); + + }, + + setValue: function ( array, offset ) { + + var bindings = this._bindings; + + for ( var i = this._targetGroup.nCachedObjects_, + n = bindings.length; i !== n; ++ i ) { + + bindings[ i ].setValue( array, offset ); + + } + + }, + + bind: function () { + + var bindings = this._bindings; + + for ( var i = this._targetGroup.nCachedObjects_, + n = bindings.length; i !== n; ++ i ) { + + bindings[ i ].bind(); + + } + + }, + + unbind: function () { + + var bindings = this._bindings; + + for ( var i = this._targetGroup.nCachedObjects_, + n = bindings.length; i !== n; ++ i ) { + + bindings[ i ].unbind(); + + } + + } + + } ); + + + function PropertyBinding( rootNode, path, parsedPath ) { + + this.path = path; + this.parsedPath = parsedPath || PropertyBinding.parseTrackName( path ); + + this.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName ) || rootNode; + + this.rootNode = rootNode; + + } + + Object.assign( PropertyBinding, { + + Composite: Composite, + + create: function ( root, path, parsedPath ) { + + if ( ! ( root && root.isAnimationObjectGroup ) ) { + + return new PropertyBinding( root, path, parsedPath ); + + } else { + + return new PropertyBinding.Composite( root, path, parsedPath ); + + } + + }, + + /** + * Replaces spaces with underscores and removes unsupported characters from + * node names, to ensure compatibility with parseTrackName(). + * + * @param {string} name Node name to be sanitized. + * @return {string} + */ + sanitizeNodeName: function ( name ) { + + return name.replace( /\s/g, '_' ).replace( /[^\w-]/g, '' ); + + }, + + parseTrackName: function () { + + // Parent directories, delimited by '/' or ':'. Currently unused, but must + // be matched to parse the rest of the track name. + var directoryRe = /((?:[\w-]+[\/:])*)/; + + // Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'. + var nodeRe = /([\w-\.]+)?/; + + // Object on target node, and accessor. Name may contain only word + // characters. Accessor may contain any character except closing bracket. + var objectRe = /(?:\.([\w-]+)(?:\[(.+)\])?)?/; + + // Property and accessor. May contain only word characters. Accessor may + // contain any non-bracket characters. + var propertyRe = /\.([\w-]+)(?:\[(.+)\])?/; + + var trackRe = new RegExp( '' + + '^' + + directoryRe.source + + nodeRe.source + + objectRe.source + + propertyRe.source + + '$' + ); + + var supportedObjectNames = [ 'material', 'materials', 'bones' ]; + + return function ( trackName ) { + + var matches = trackRe.exec( trackName ); + + if ( ! matches ) { + + throw new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName ); + + } + + var results = { + // directoryName: matches[ 1 ], // (tschw) currently unused + nodeName: matches[ 2 ], + objectName: matches[ 3 ], + objectIndex: matches[ 4 ], + propertyName: matches[ 5 ], // required + propertyIndex: matches[ 6 ] + }; + + var lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' ); + + if ( lastDot !== undefined && lastDot !== - 1 ) { + + var objectName = results.nodeName.substring( lastDot + 1 ); + + // Object names must be checked against a whitelist. Otherwise, there + // is no way to parse 'foo.bar.baz': 'baz' must be a property, but + // 'bar' could be the objectName, or part of a nodeName (which can + // include '.' characters). + if ( supportedObjectNames.indexOf( objectName ) !== - 1 ) { + + results.nodeName = results.nodeName.substring( 0, lastDot ); + results.objectName = objectName; + + } + + } + + if ( results.propertyName === null || results.propertyName.length === 0 ) { + + throw new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName ); + + } + + return results; + + }; + + }(), + + findNode: function ( root, nodeName ) { + + if ( ! nodeName || nodeName === "" || nodeName === "root" || nodeName === "." || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) { + + return root; + + } + + // search into skeleton bones. + if ( root.skeleton ) { + + var searchSkeleton = function ( skeleton ) { + + for ( var i = 0; i < skeleton.bones.length; i ++ ) { + + var bone = skeleton.bones[ i ]; + + if ( bone.name === nodeName ) { + + return bone; + + } + + } + + return null; + + }; + + var bone = searchSkeleton( root.skeleton ); + + if ( bone ) { + + return bone; + + } + + } + + // search into node subtree. + if ( root.children ) { + + var searchNodeSubtree = function ( children ) { + + for ( var i = 0; i < children.length; i ++ ) { + + var childNode = children[ i ]; + + if ( childNode.name === nodeName || childNode.uuid === nodeName ) { + + return childNode; + + } + + var result = searchNodeSubtree( childNode.children ); + + if ( result ) return result; + + } + + return null; + + }; + + var subTreeNode = searchNodeSubtree( root.children ); + + if ( subTreeNode ) { + + return subTreeNode; + + } + + } + + return null; + + } + + } ); + + Object.assign( PropertyBinding.prototype, { // prototype, continued + + // these are used to "bind" a nonexistent property + _getValue_unavailable: function () {}, + _setValue_unavailable: function () {}, + + BindingType: { + Direct: 0, + EntireArray: 1, + ArrayElement: 2, + HasFromToArray: 3 + }, + + Versioning: { + None: 0, + NeedsUpdate: 1, + MatrixWorldNeedsUpdate: 2 + }, + + GetterByBindingType: [ + + function getValue_direct( buffer, offset ) { + + buffer[ offset ] = this.node[ this.propertyName ]; + + }, + + function getValue_array( buffer, offset ) { + + var source = this.resolvedProperty; + + for ( var i = 0, n = source.length; i !== n; ++ i ) { + + buffer[ offset ++ ] = source[ i ]; + + } + + }, + + function getValue_arrayElement( buffer, offset ) { + + buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ]; + + }, + + function getValue_toArray( buffer, offset ) { + + this.resolvedProperty.toArray( buffer, offset ); + + } + + ], + + SetterByBindingTypeAndVersioning: [ + + [ + // Direct + + function setValue_direct( buffer, offset ) { + + this.targetObject[ this.propertyName ] = buffer[ offset ]; + + }, + + function setValue_direct_setNeedsUpdate( buffer, offset ) { + + this.targetObject[ this.propertyName ] = buffer[ offset ]; + this.targetObject.needsUpdate = true; + + }, + + function setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) { + + this.targetObject[ this.propertyName ] = buffer[ offset ]; + this.targetObject.matrixWorldNeedsUpdate = true; + + } + + ], [ + + // EntireArray + + function setValue_array( buffer, offset ) { + + var dest = this.resolvedProperty; + + for ( var i = 0, n = dest.length; i !== n; ++ i ) { + + dest[ i ] = buffer[ offset ++ ]; + + } + + }, + + function setValue_array_setNeedsUpdate( buffer, offset ) { + + var dest = this.resolvedProperty; + + for ( var i = 0, n = dest.length; i !== n; ++ i ) { + + dest[ i ] = buffer[ offset ++ ]; + + } + + this.targetObject.needsUpdate = true; + + }, + + function setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) { + + var dest = this.resolvedProperty; + + for ( var i = 0, n = dest.length; i !== n; ++ i ) { + + dest[ i ] = buffer[ offset ++ ]; + + } + + this.targetObject.matrixWorldNeedsUpdate = true; + + } + + ], [ + + // ArrayElement + + function setValue_arrayElement( buffer, offset ) { + + this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; + + }, + + function setValue_arrayElement_setNeedsUpdate( buffer, offset ) { + + this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; + this.targetObject.needsUpdate = true; + + }, + + function setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) { + + this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; + this.targetObject.matrixWorldNeedsUpdate = true; + + } + + ], [ + + // HasToFromArray + + function setValue_fromArray( buffer, offset ) { + + this.resolvedProperty.fromArray( buffer, offset ); + + }, + + function setValue_fromArray_setNeedsUpdate( buffer, offset ) { + + this.resolvedProperty.fromArray( buffer, offset ); + this.targetObject.needsUpdate = true; + + }, + + function setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) { + + this.resolvedProperty.fromArray( buffer, offset ); + this.targetObject.matrixWorldNeedsUpdate = true; + + } + + ] + + ], + + getValue: function getValue_unbound( targetArray, offset ) { + + this.bind(); + this.getValue( targetArray, offset ); + + // Note: This class uses a State pattern on a per-method basis: + // 'bind' sets 'this.getValue' / 'setValue' and shadows the + // prototype version of these methods with one that represents + // the bound state. When the property is not found, the methods + // become no-ops. + + }, + + setValue: function getValue_unbound( sourceArray, offset ) { + + this.bind(); + this.setValue( sourceArray, offset ); + + }, + + // create getter / setter pair for a property in the scene graph + bind: function () { + + var targetObject = this.node, + parsedPath = this.parsedPath, + + objectName = parsedPath.objectName, + propertyName = parsedPath.propertyName, + propertyIndex = parsedPath.propertyIndex; + + if ( ! targetObject ) { + + targetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName ) || this.rootNode; + + this.node = targetObject; + + } + + // set fail state so we can just 'return' on error + this.getValue = this._getValue_unavailable; + this.setValue = this._setValue_unavailable; + + // ensure there is a value node + if ( ! targetObject ) { + + console.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\'t found.' ); + return; + + } + + if ( objectName ) { + + var objectIndex = parsedPath.objectIndex; + + // special cases were we need to reach deeper into the hierarchy to get the face materials.... + switch ( objectName ) { + + case 'materials': + + if ( ! targetObject.material ) { + + console.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this ); + return; + + } + + if ( ! targetObject.material.materials ) { + + console.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this ); + return; + + } + + targetObject = targetObject.material.materials; + + break; + + case 'bones': + + if ( ! targetObject.skeleton ) { + + console.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this ); + return; + + } + + // potential future optimization: skip this if propertyIndex is already an integer + // and convert the integer string to a true integer. + + targetObject = targetObject.skeleton.bones; + + // support resolving morphTarget names into indices. + for ( var i = 0; i < targetObject.length; i ++ ) { + + if ( targetObject[ i ].name === objectIndex ) { + + objectIndex = i; + break; + + } + + } + + break; + + default: + + if ( targetObject[ objectName ] === undefined ) { + + console.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this ); + return; + + } + + targetObject = targetObject[ objectName ]; + + } + + + if ( objectIndex !== undefined ) { + + if ( targetObject[ objectIndex ] === undefined ) { + + console.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject ); + return; + + } + + targetObject = targetObject[ objectIndex ]; + + } + + } + + // resolve property + var nodeProperty = targetObject[ propertyName ]; + + if ( nodeProperty === undefined ) { + + var nodeName = parsedPath.nodeName; + + console.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName + + '.' + propertyName + ' but it wasn\'t found.', targetObject ); + return; + + } + + // determine versioning scheme + var versioning = this.Versioning.None; + + if ( targetObject.needsUpdate !== undefined ) { // material + + versioning = this.Versioning.NeedsUpdate; + this.targetObject = targetObject; + + } else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform + + versioning = this.Versioning.MatrixWorldNeedsUpdate; + this.targetObject = targetObject; + + } + + // determine how the property gets bound + var bindingType = this.BindingType.Direct; + + if ( propertyIndex !== undefined ) { + + // access a sub element of the property array (only primitives are supported right now) + + if ( propertyName === "morphTargetInfluences" ) { + + // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer. + + // support resolving morphTarget names into indices. + if ( ! targetObject.geometry ) { + + console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this ); + return; + + } + + if ( targetObject.geometry.isBufferGeometry ) { + + if ( ! targetObject.geometry.morphAttributes ) { + + console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this ); + return; + + } + + for ( var i = 0; i < this.node.geometry.morphAttributes.position.length; i ++ ) { + + if ( targetObject.geometry.morphAttributes.position[ i ].name === propertyIndex ) { + + propertyIndex = i; + break; + + } + + } + + + } else { + + if ( ! targetObject.geometry.morphTargets ) { + + console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.', this ); + return; + + } + + for ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) { + + if ( targetObject.geometry.morphTargets[ i ].name === propertyIndex ) { + + propertyIndex = i; + break; + + } + + } + + } + + } + + bindingType = this.BindingType.ArrayElement; + + this.resolvedProperty = nodeProperty; + this.propertyIndex = propertyIndex; + + } else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) { + + // must use copy for Object3D.Euler/Quaternion + + bindingType = this.BindingType.HasFromToArray; + + this.resolvedProperty = nodeProperty; + + } else if ( Array.isArray( nodeProperty ) ) { + + bindingType = this.BindingType.EntireArray; + + this.resolvedProperty = nodeProperty; + + } else { + + this.propertyName = propertyName; + + } + + // select getter / setter + this.getValue = this.GetterByBindingType[ bindingType ]; + this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ]; + + }, + + unbind: function () { + + this.node = null; + + // back to the prototype version of getValue / setValue + // note: avoiding to mutate the shape of 'this' via 'delete' + this.getValue = this._getValue_unbound; + this.setValue = this._setValue_unbound; + + } + + } ); + + //!\ DECLARE ALIAS AFTER assign prototype ! + Object.assign( PropertyBinding.prototype, { + + // initial state of these methods that calls 'bind' + _getValue_unbound: PropertyBinding.prototype.getValue, + _setValue_unbound: PropertyBinding.prototype.setValue, + + } ); + + /** + * + * A group of objects that receives a shared animation state. + * + * Usage: + * + * - Add objects you would otherwise pass as 'root' to the + * constructor or the .clipAction method of AnimationMixer. + * + * - Instead pass this object as 'root'. + * + * - You can also add and remove objects later when the mixer + * is running. + * + * Note: + * + * Objects of this class appear as one object to the mixer, + * so cache control of the individual objects must be done + * on the group. + * + * Limitation: + * + * - The animated properties must be compatible among the + * all objects in the group. + * + * - A single property can either be controlled through a + * target group or directly, but not both. + * + * @author tschw + */ + + function AnimationObjectGroup() { + + this.uuid = _Math.generateUUID(); + + // cached objects followed by the active ones + this._objects = Array.prototype.slice.call( arguments ); + + this.nCachedObjects_ = 0; // threshold + // note: read by PropertyBinding.Composite + + var indices = {}; + this._indicesByUUID = indices; // for bookkeeping + + for ( var i = 0, n = arguments.length; i !== n; ++ i ) { + + indices[ arguments[ i ].uuid ] = i; + + } + + this._paths = []; // inside: string + this._parsedPaths = []; // inside: { we don't care, here } + this._bindings = []; // inside: Array< PropertyBinding > + this._bindingsIndicesByPath = {}; // inside: indices in these arrays + + var scope = this; + + this.stats = { + + objects: { + get total() { + + return scope._objects.length; + + }, + get inUse() { + + return this.total - scope.nCachedObjects_; + + } + }, + get bindingsPerObject() { + + return scope._bindings.length; + + } + + }; + + } + + Object.assign( AnimationObjectGroup.prototype, { + + isAnimationObjectGroup: true, + + add: function () { + + var objects = this._objects, + nObjects = objects.length, + nCachedObjects = this.nCachedObjects_, + indicesByUUID = this._indicesByUUID, + paths = this._paths, + parsedPaths = this._parsedPaths, + bindings = this._bindings, + nBindings = bindings.length; + + for ( var i = 0, n = arguments.length; i !== n; ++ i ) { + + var object = arguments[ i ], + uuid = object.uuid, + index = indicesByUUID[ uuid ], + knownObject = undefined; + + if ( index === undefined ) { + + // unknown object -> add it to the ACTIVE region + + index = nObjects ++; + indicesByUUID[ uuid ] = index; + objects.push( object ); + + // accounting is done, now do the same for all bindings + + for ( var j = 0, m = nBindings; j !== m; ++ j ) { + + bindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) ); + + } + + } else if ( index < nCachedObjects ) { + + knownObject = objects[ index ]; + + // move existing object to the ACTIVE region + + var firstActiveIndex = -- nCachedObjects, + lastCachedObject = objects[ firstActiveIndex ]; + + indicesByUUID[ lastCachedObject.uuid ] = index; + objects[ index ] = lastCachedObject; + + indicesByUUID[ uuid ] = firstActiveIndex; + objects[ firstActiveIndex ] = object; + + // accounting is done, now do the same for all bindings + + for ( var j = 0, m = nBindings; j !== m; ++ j ) { + + var bindingsForPath = bindings[ j ], + lastCached = bindingsForPath[ firstActiveIndex ], + binding = bindingsForPath[ index ]; + + bindingsForPath[ index ] = lastCached; + + if ( binding === undefined ) { + + // since we do not bother to create new bindings + // for objects that are cached, the binding may + // or may not exist + + binding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ); + + } + + bindingsForPath[ firstActiveIndex ] = binding; + + } + + } else if ( objects[ index ] !== knownObject ) { + + console.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' + + 'detected. Clean the caches or recreate your infrastructure when reloading scenes.' ); + + } // else the object is already where we want it to be + + } // for arguments + + this.nCachedObjects_ = nCachedObjects; + + }, + + remove: function () { + + var objects = this._objects, + nCachedObjects = this.nCachedObjects_, + indicesByUUID = this._indicesByUUID, + bindings = this._bindings, + nBindings = bindings.length; + + for ( var i = 0, n = arguments.length; i !== n; ++ i ) { + + var object = arguments[ i ], + uuid = object.uuid, + index = indicesByUUID[ uuid ]; + + if ( index !== undefined && index >= nCachedObjects ) { + + // move existing object into the CACHED region + + var lastCachedIndex = nCachedObjects ++, + firstActiveObject = objects[ lastCachedIndex ]; + + indicesByUUID[ firstActiveObject.uuid ] = index; + objects[ index ] = firstActiveObject; + + indicesByUUID[ uuid ] = lastCachedIndex; + objects[ lastCachedIndex ] = object; + + // accounting is done, now do the same for all bindings + + for ( var j = 0, m = nBindings; j !== m; ++ j ) { + + var bindingsForPath = bindings[ j ], + firstActive = bindingsForPath[ lastCachedIndex ], + binding = bindingsForPath[ index ]; + + bindingsForPath[ index ] = firstActive; + bindingsForPath[ lastCachedIndex ] = binding; + + } + + } + + } // for arguments + + this.nCachedObjects_ = nCachedObjects; + + }, + + // remove & forget + uncache: function () { + + var objects = this._objects, + nObjects = objects.length, + nCachedObjects = this.nCachedObjects_, + indicesByUUID = this._indicesByUUID, + bindings = this._bindings, + nBindings = bindings.length; + + for ( var i = 0, n = arguments.length; i !== n; ++ i ) { + + var object = arguments[ i ], + uuid = object.uuid, + index = indicesByUUID[ uuid ]; + + if ( index !== undefined ) { + + delete indicesByUUID[ uuid ]; + + if ( index < nCachedObjects ) { + + // object is cached, shrink the CACHED region + + var firstActiveIndex = -- nCachedObjects, + lastCachedObject = objects[ firstActiveIndex ], + lastIndex = -- nObjects, + lastObject = objects[ lastIndex ]; + + // last cached object takes this object's place + indicesByUUID[ lastCachedObject.uuid ] = index; + objects[ index ] = lastCachedObject; + + // last object goes to the activated slot and pop + indicesByUUID[ lastObject.uuid ] = firstActiveIndex; + objects[ firstActiveIndex ] = lastObject; + objects.pop(); + + // accounting is done, now do the same for all bindings + + for ( var j = 0, m = nBindings; j !== m; ++ j ) { + + var bindingsForPath = bindings[ j ], + lastCached = bindingsForPath[ firstActiveIndex ], + last = bindingsForPath[ lastIndex ]; + + bindingsForPath[ index ] = lastCached; + bindingsForPath[ firstActiveIndex ] = last; + bindingsForPath.pop(); + + } + + } else { + + // object is active, just swap with the last and pop + + var lastIndex = -- nObjects, + lastObject = objects[ lastIndex ]; + + indicesByUUID[ lastObject.uuid ] = index; + objects[ index ] = lastObject; + objects.pop(); + + // accounting is done, now do the same for all bindings + + for ( var j = 0, m = nBindings; j !== m; ++ j ) { + + var bindingsForPath = bindings[ j ]; + + bindingsForPath[ index ] = bindingsForPath[ lastIndex ]; + bindingsForPath.pop(); + + } + + } // cached or active + + } // if object is known + + } // for arguments + + this.nCachedObjects_ = nCachedObjects; + + }, + + // Internal interface used by befriended PropertyBinding.Composite: + + subscribe_: function ( path, parsedPath ) { + + // returns an array of bindings for the given path that is changed + // according to the contained objects in the group + + var indicesByPath = this._bindingsIndicesByPath, + index = indicesByPath[ path ], + bindings = this._bindings; + + if ( index !== undefined ) return bindings[ index ]; + + var paths = this._paths, + parsedPaths = this._parsedPaths, + objects = this._objects, + nObjects = objects.length, + nCachedObjects = this.nCachedObjects_, + bindingsForPath = new Array( nObjects ); + + index = bindings.length; + + indicesByPath[ path ] = index; + + paths.push( path ); + parsedPaths.push( parsedPath ); + bindings.push( bindingsForPath ); + + for ( var i = nCachedObjects, n = objects.length; i !== n; ++ i ) { + + var object = objects[ i ]; + bindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath ); + + } + + return bindingsForPath; + + }, + + unsubscribe_: function ( path ) { + + // tells the group to forget about a property path and no longer + // update the array previously obtained with 'subscribe_' + + var indicesByPath = this._bindingsIndicesByPath, + index = indicesByPath[ path ]; + + if ( index !== undefined ) { + + var paths = this._paths, + parsedPaths = this._parsedPaths, + bindings = this._bindings, + lastBindingsIndex = bindings.length - 1, + lastBindings = bindings[ lastBindingsIndex ], + lastBindingsPath = path[ lastBindingsIndex ]; + + indicesByPath[ lastBindingsPath ] = index; + + bindings[ index ] = lastBindings; + bindings.pop(); + + parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ]; + parsedPaths.pop(); + + paths[ index ] = paths[ lastBindingsIndex ]; + paths.pop(); + + } + + } + + } ); + + /** + * + * Action provided by AnimationMixer for scheduling clip playback on specific + * objects. + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + * + */ + + function AnimationAction( mixer, clip, localRoot ) { + + this._mixer = mixer; + this._clip = clip; + this._localRoot = localRoot || null; + + var tracks = clip.tracks, + nTracks = tracks.length, + interpolants = new Array( nTracks ); + + var interpolantSettings = { + endingStart: ZeroCurvatureEnding, + endingEnd: ZeroCurvatureEnding + }; + + for ( var i = 0; i !== nTracks; ++ i ) { + + var interpolant = tracks[ i ].createInterpolant( null ); + interpolants[ i ] = interpolant; + interpolant.settings = interpolantSettings; + + } + + this._interpolantSettings = interpolantSettings; + + this._interpolants = interpolants; // bound by the mixer + + // inside: PropertyMixer (managed by the mixer) + this._propertyBindings = new Array( nTracks ); + + this._cacheIndex = null; // for the memory manager + this._byClipCacheIndex = null; // for the memory manager + + this._timeScaleInterpolant = null; + this._weightInterpolant = null; + + this.loop = LoopRepeat; + this._loopCount = - 1; + + // global mixer time when the action is to be started + // it's set back to 'null' upon start of the action + this._startTime = null; + + // scaled local time of the action + // gets clamped or wrapped to 0..clip.duration according to loop + this.time = 0; + + this.timeScale = 1; + this._effectiveTimeScale = 1; + + this.weight = 1; + this._effectiveWeight = 1; + + this.repetitions = Infinity; // no. of repetitions when looping + + this.paused = false; // true -> zero effective time scale + this.enabled = true; // false -> zero effective weight + + this.clampWhenFinished = false; // keep feeding the last frame? + + this.zeroSlopeAtStart = true; // for smooth interpolation w/o separate + this.zeroSlopeAtEnd = true; // clips for start, loop and end + + } + + Object.assign( AnimationAction.prototype, { + + // State & Scheduling + + play: function () { + + this._mixer._activateAction( this ); + + return this; + + }, + + stop: function () { + + this._mixer._deactivateAction( this ); + + return this.reset(); + + }, + + reset: function () { + + this.paused = false; + this.enabled = true; + + this.time = 0; // restart clip + this._loopCount = - 1; // forget previous loops + this._startTime = null; // forget scheduling + + return this.stopFading().stopWarping(); + + }, + + isRunning: function () { + + return this.enabled && ! this.paused && this.timeScale !== 0 && + this._startTime === null && this._mixer._isActiveAction( this ); + + }, + + // return true when play has been called + isScheduled: function () { + + return this._mixer._isActiveAction( this ); + + }, + + startAt: function ( time ) { + + this._startTime = time; + + return this; + + }, + + setLoop: function ( mode, repetitions ) { + + this.loop = mode; + this.repetitions = repetitions; + + return this; + + }, + + // Weight + + // set the weight stopping any scheduled fading + // although .enabled = false yields an effective weight of zero, this + // method does *not* change .enabled, because it would be confusing + setEffectiveWeight: function ( weight ) { + + this.weight = weight; + + // note: same logic as when updated at runtime + this._effectiveWeight = this.enabled ? weight : 0; + + return this.stopFading(); + + }, + + // return the weight considering fading and .enabled + getEffectiveWeight: function () { + + return this._effectiveWeight; + + }, + + fadeIn: function ( duration ) { + + return this._scheduleFading( duration, 0, 1 ); + + }, + + fadeOut: function ( duration ) { + + return this._scheduleFading( duration, 1, 0 ); + + }, + + crossFadeFrom: function ( fadeOutAction, duration, warp ) { + + fadeOutAction.fadeOut( duration ); + this.fadeIn( duration ); + + if ( warp ) { + + var fadeInDuration = this._clip.duration, + fadeOutDuration = fadeOutAction._clip.duration, + + startEndRatio = fadeOutDuration / fadeInDuration, + endStartRatio = fadeInDuration / fadeOutDuration; + + fadeOutAction.warp( 1.0, startEndRatio, duration ); + this.warp( endStartRatio, 1.0, duration ); + + } + + return this; + + }, + + crossFadeTo: function ( fadeInAction, duration, warp ) { + + return fadeInAction.crossFadeFrom( this, duration, warp ); + + }, + + stopFading: function () { + + var weightInterpolant = this._weightInterpolant; + + if ( weightInterpolant !== null ) { + + this._weightInterpolant = null; + this._mixer._takeBackControlInterpolant( weightInterpolant ); + + } + + return this; + + }, + + // Time Scale Control + + // set the time scale stopping any scheduled warping + // although .paused = true yields an effective time scale of zero, this + // method does *not* change .paused, because it would be confusing + setEffectiveTimeScale: function ( timeScale ) { + + this.timeScale = timeScale; + this._effectiveTimeScale = this.paused ? 0 : timeScale; + + return this.stopWarping(); + + }, + + // return the time scale considering warping and .paused + getEffectiveTimeScale: function () { + + return this._effectiveTimeScale; + + }, + + setDuration: function ( duration ) { + + this.timeScale = this._clip.duration / duration; + + return this.stopWarping(); + + }, + + syncWith: function ( action ) { + + this.time = action.time; + this.timeScale = action.timeScale; + + return this.stopWarping(); + + }, + + halt: function ( duration ) { + + return this.warp( this._effectiveTimeScale, 0, duration ); + + }, + + warp: function ( startTimeScale, endTimeScale, duration ) { + + var mixer = this._mixer, now = mixer.time, + interpolant = this._timeScaleInterpolant, + + timeScale = this.timeScale; + + if ( interpolant === null ) { + + interpolant = mixer._lendControlInterpolant(); + this._timeScaleInterpolant = interpolant; + + } + + var times = interpolant.parameterPositions, + values = interpolant.sampleValues; + + times[ 0 ] = now; + times[ 1 ] = now + duration; + + values[ 0 ] = startTimeScale / timeScale; + values[ 1 ] = endTimeScale / timeScale; + + return this; + + }, + + stopWarping: function () { + + var timeScaleInterpolant = this._timeScaleInterpolant; + + if ( timeScaleInterpolant !== null ) { + + this._timeScaleInterpolant = null; + this._mixer._takeBackControlInterpolant( timeScaleInterpolant ); + + } + + return this; + + }, + + // Object Accessors + + getMixer: function () { + + return this._mixer; + + }, + + getClip: function () { + + return this._clip; + + }, + + getRoot: function () { + + return this._localRoot || this._mixer._root; + + }, + + // Interna + + _update: function ( time, deltaTime, timeDirection, accuIndex ) { + + // called by the mixer + + if ( ! this.enabled ) { + + // call ._updateWeight() to update ._effectiveWeight + + this._updateWeight( time ); + return; + + } + + var startTime = this._startTime; + + if ( startTime !== null ) { + + // check for scheduled start of action + + var timeRunning = ( time - startTime ) * timeDirection; + if ( timeRunning < 0 || timeDirection === 0 ) { + + return; // yet to come / don't decide when delta = 0 + + } + + // start + + this._startTime = null; // unschedule + deltaTime = timeDirection * timeRunning; + + } + + // apply time scale and advance time + + deltaTime *= this._updateTimeScale( time ); + var clipTime = this._updateTime( deltaTime ); + + // note: _updateTime may disable the action resulting in + // an effective weight of 0 + + var weight = this._updateWeight( time ); + + if ( weight > 0 ) { + + var interpolants = this._interpolants; + var propertyMixers = this._propertyBindings; + + for ( var j = 0, m = interpolants.length; j !== m; ++ j ) { + + interpolants[ j ].evaluate( clipTime ); + propertyMixers[ j ].accumulate( accuIndex, weight ); + + } + + } + + }, + + _updateWeight: function ( time ) { + + var weight = 0; + + if ( this.enabled ) { + + weight = this.weight; + var interpolant = this._weightInterpolant; + + if ( interpolant !== null ) { + + var interpolantValue = interpolant.evaluate( time )[ 0 ]; + + weight *= interpolantValue; + + if ( time > interpolant.parameterPositions[ 1 ] ) { + + this.stopFading(); + + if ( interpolantValue === 0 ) { + + // faded out, disable + this.enabled = false; + + } + + } + + } + + } + + this._effectiveWeight = weight; + return weight; + + }, + + _updateTimeScale: function ( time ) { + + var timeScale = 0; + + if ( ! this.paused ) { + + timeScale = this.timeScale; + + var interpolant = this._timeScaleInterpolant; + + if ( interpolant !== null ) { + + var interpolantValue = interpolant.evaluate( time )[ 0 ]; + + timeScale *= interpolantValue; + + if ( time > interpolant.parameterPositions[ 1 ] ) { + + this.stopWarping(); + + if ( timeScale === 0 ) { + + // motion has halted, pause + this.paused = true; + + } else { + + // warp done - apply final time scale + this.timeScale = timeScale; + + } + + } + + } + + } + + this._effectiveTimeScale = timeScale; + return timeScale; + + }, + + _updateTime: function ( deltaTime ) { + + var time = this.time + deltaTime; + + if ( deltaTime === 0 ) return time; + + var duration = this._clip.duration, + + loop = this.loop, + loopCount = this._loopCount; + + if ( loop === LoopOnce ) { + + if ( loopCount === - 1 ) { + + // just started + + this._loopCount = 0; + this._setEndings( true, true, false ); + + } + + handle_stop: { + + if ( time >= duration ) { + + time = duration; + + } else if ( time < 0 ) { + + time = 0; + + } else break handle_stop; + + if ( this.clampWhenFinished ) this.paused = true; + else this.enabled = false; + + this._mixer.dispatchEvent( { + type: 'finished', action: this, + direction: deltaTime < 0 ? - 1 : 1 + } ); + + } + + } else { // repetitive Repeat or PingPong + + var pingPong = ( loop === LoopPingPong ); + + if ( loopCount === - 1 ) { + + // just started + + if ( deltaTime >= 0 ) { + + loopCount = 0; + + this._setEndings( true, this.repetitions === 0, pingPong ); + + } else { + + // when looping in reverse direction, the initial + // transition through zero counts as a repetition, + // so leave loopCount at -1 + + this._setEndings( this.repetitions === 0, true, pingPong ); + + } + + } + + if ( time >= duration || time < 0 ) { + + // wrap around + + var loopDelta = Math.floor( time / duration ); // signed + time -= duration * loopDelta; + + loopCount += Math.abs( loopDelta ); + + var pending = this.repetitions - loopCount; + + if ( pending < 0 ) { + + // have to stop (switch state, clamp time, fire event) + + if ( this.clampWhenFinished ) this.paused = true; + else this.enabled = false; + + time = deltaTime > 0 ? duration : 0; + + this._mixer.dispatchEvent( { + type: 'finished', action: this, + direction: deltaTime > 0 ? 1 : - 1 + } ); + + } else { + + // keep running + + if ( pending === 0 ) { + + // entering the last round + + var atStart = deltaTime < 0; + this._setEndings( atStart, ! atStart, pingPong ); + + } else { + + this._setEndings( false, false, pingPong ); + + } + + this._loopCount = loopCount; + + this._mixer.dispatchEvent( { + type: 'loop', action: this, loopDelta: loopDelta + } ); + + } + + } + + if ( pingPong && ( loopCount & 1 ) === 1 ) { + + // invert time for the "pong round" + + this.time = time; + return duration - time; + + } + + } + + this.time = time; + return time; + + }, + + _setEndings: function ( atStart, atEnd, pingPong ) { + + var settings = this._interpolantSettings; + + if ( pingPong ) { + + settings.endingStart = ZeroSlopeEnding; + settings.endingEnd = ZeroSlopeEnding; + + } else { + + // assuming for LoopOnce atStart == atEnd == true + + if ( atStart ) { + + settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding; + + } else { + + settings.endingStart = WrapAroundEnding; + + } + + if ( atEnd ) { + + settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding; + + } else { + + settings.endingEnd = WrapAroundEnding; + + } + + } + + }, + + _scheduleFading: function ( duration, weightNow, weightThen ) { + + var mixer = this._mixer, now = mixer.time, + interpolant = this._weightInterpolant; + + if ( interpolant === null ) { + + interpolant = mixer._lendControlInterpolant(); + this._weightInterpolant = interpolant; + + } + + var times = interpolant.parameterPositions, + values = interpolant.sampleValues; + + times[ 0 ] = now; values[ 0 ] = weightNow; + times[ 1 ] = now + duration; values[ 1 ] = weightThen; + + return this; + + } + + } ); + + /** + * + * Player for AnimationClips. + * + * + * @author Ben Houston / http://clara.io/ + * @author David Sarno / http://lighthaus.us/ + * @author tschw + */ + + function AnimationMixer( root ) { + + this._root = root; + this._initMemoryManager(); + this._accuIndex = 0; + + this.time = 0; + + this.timeScale = 1.0; + + } + + AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { + + constructor: AnimationMixer, + + _bindAction: function ( action, prototypeAction ) { + + var root = action._localRoot || this._root, + tracks = action._clip.tracks, + nTracks = tracks.length, + bindings = action._propertyBindings, + interpolants = action._interpolants, + rootUuid = root.uuid, + bindingsByRoot = this._bindingsByRootAndName, + bindingsByName = bindingsByRoot[ rootUuid ]; + + if ( bindingsByName === undefined ) { + + bindingsByName = {}; + bindingsByRoot[ rootUuid ] = bindingsByName; + + } + + for ( var i = 0; i !== nTracks; ++ i ) { + + var track = tracks[ i ], + trackName = track.name, + binding = bindingsByName[ trackName ]; + + if ( binding !== undefined ) { + + bindings[ i ] = binding; + + } else { + + binding = bindings[ i ]; + + if ( binding !== undefined ) { + + // existing binding, make sure the cache knows + + if ( binding._cacheIndex === null ) { + + ++ binding.referenceCount; + this._addInactiveBinding( binding, rootUuid, trackName ); + + } + + continue; + + } + + var path = prototypeAction && prototypeAction. + _propertyBindings[ i ].binding.parsedPath; + + binding = new PropertyMixer( + PropertyBinding.create( root, trackName, path ), + track.ValueTypeName, track.getValueSize() ); + + ++ binding.referenceCount; + this._addInactiveBinding( binding, rootUuid, trackName ); + + bindings[ i ] = binding; + + } + + interpolants[ i ].resultBuffer = binding.buffer; + + } + + }, + + _activateAction: function ( action ) { + + if ( ! this._isActiveAction( action ) ) { + + if ( action._cacheIndex === null ) { + + // this action has been forgotten by the cache, but the user + // appears to be still using it -> rebind + + var rootUuid = ( action._localRoot || this._root ).uuid, + clipUuid = action._clip.uuid, + actionsForClip = this._actionsByClip[ clipUuid ]; + + this._bindAction( action, + actionsForClip && actionsForClip.knownActions[ 0 ] ); + + this._addInactiveAction( action, clipUuid, rootUuid ); + + } + + var bindings = action._propertyBindings; + + // increment reference counts / sort out state + for ( var i = 0, n = bindings.length; i !== n; ++ i ) { + + var binding = bindings[ i ]; + + if ( binding.useCount ++ === 0 ) { + + this._lendBinding( binding ); + binding.saveOriginalState(); + + } + + } + + this._lendAction( action ); + + } + + }, + + _deactivateAction: function ( action ) { + + if ( this._isActiveAction( action ) ) { + + var bindings = action._propertyBindings; + + // decrement reference counts / sort out state + for ( var i = 0, n = bindings.length; i !== n; ++ i ) { + + var binding = bindings[ i ]; + + if ( -- binding.useCount === 0 ) { + + binding.restoreOriginalState(); + this._takeBackBinding( binding ); + + } + + } + + this._takeBackAction( action ); + + } + + }, + + // Memory manager + + _initMemoryManager: function () { + + this._actions = []; // 'nActiveActions' followed by inactive ones + this._nActiveActions = 0; + + this._actionsByClip = {}; + // inside: + // { + // knownActions: Array< AnimationAction > - used as prototypes + // actionByRoot: AnimationAction - lookup + // } + + + this._bindings = []; // 'nActiveBindings' followed by inactive ones + this._nActiveBindings = 0; + + this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer > + + + this._controlInterpolants = []; // same game as above + this._nActiveControlInterpolants = 0; + + var scope = this; + + this.stats = { + + actions: { + get total() { + + return scope._actions.length; + + }, + get inUse() { + + return scope._nActiveActions; + + } + }, + bindings: { + get total() { + + return scope._bindings.length; + + }, + get inUse() { + + return scope._nActiveBindings; + + } + }, + controlInterpolants: { + get total() { + + return scope._controlInterpolants.length; + + }, + get inUse() { + + return scope._nActiveControlInterpolants; + + } + } + + }; + + }, + + // Memory management for AnimationAction objects + + _isActiveAction: function ( action ) { + + var index = action._cacheIndex; + return index !== null && index < this._nActiveActions; + + }, + + _addInactiveAction: function ( action, clipUuid, rootUuid ) { + + var actions = this._actions, + actionsByClip = this._actionsByClip, + actionsForClip = actionsByClip[ clipUuid ]; + + if ( actionsForClip === undefined ) { + + actionsForClip = { + + knownActions: [ action ], + actionByRoot: {} + + }; + + action._byClipCacheIndex = 0; + + actionsByClip[ clipUuid ] = actionsForClip; + + } else { + + var knownActions = actionsForClip.knownActions; + + action._byClipCacheIndex = knownActions.length; + knownActions.push( action ); + + } + + action._cacheIndex = actions.length; + actions.push( action ); + + actionsForClip.actionByRoot[ rootUuid ] = action; + + }, + + _removeInactiveAction: function ( action ) { + + var actions = this._actions, + lastInactiveAction = actions[ actions.length - 1 ], + cacheIndex = action._cacheIndex; + + lastInactiveAction._cacheIndex = cacheIndex; + actions[ cacheIndex ] = lastInactiveAction; + actions.pop(); + + action._cacheIndex = null; + + + var clipUuid = action._clip.uuid, + actionsByClip = this._actionsByClip, + actionsForClip = actionsByClip[ clipUuid ], + knownActionsForClip = actionsForClip.knownActions, + + lastKnownAction = + knownActionsForClip[ knownActionsForClip.length - 1 ], + + byClipCacheIndex = action._byClipCacheIndex; + + lastKnownAction._byClipCacheIndex = byClipCacheIndex; + knownActionsForClip[ byClipCacheIndex ] = lastKnownAction; + knownActionsForClip.pop(); + + action._byClipCacheIndex = null; + + + var actionByRoot = actionsForClip.actionByRoot, + rootUuid = ( action._localRoot || this._root ).uuid; + + delete actionByRoot[ rootUuid ]; + + if ( knownActionsForClip.length === 0 ) { + + delete actionsByClip[ clipUuid ]; + + } + + this._removeInactiveBindingsForAction( action ); + + }, + + _removeInactiveBindingsForAction: function ( action ) { + + var bindings = action._propertyBindings; + for ( var i = 0, n = bindings.length; i !== n; ++ i ) { + + var binding = bindings[ i ]; + + if ( -- binding.referenceCount === 0 ) { + + this._removeInactiveBinding( binding ); + + } + + } + + }, + + _lendAction: function ( action ) { + + // [ active actions | inactive actions ] + // [ active actions >| inactive actions ] + // s a + // <-swap-> + // a s + + var actions = this._actions, + prevIndex = action._cacheIndex, + + lastActiveIndex = this._nActiveActions ++, + + firstInactiveAction = actions[ lastActiveIndex ]; + + action._cacheIndex = lastActiveIndex; + actions[ lastActiveIndex ] = action; + + firstInactiveAction._cacheIndex = prevIndex; + actions[ prevIndex ] = firstInactiveAction; + + }, + + _takeBackAction: function ( action ) { + + // [ active actions | inactive actions ] + // [ active actions |< inactive actions ] + // a s + // <-swap-> + // s a + + var actions = this._actions, + prevIndex = action._cacheIndex, + + firstInactiveIndex = -- this._nActiveActions, + + lastActiveAction = actions[ firstInactiveIndex ]; + + action._cacheIndex = firstInactiveIndex; + actions[ firstInactiveIndex ] = action; + + lastActiveAction._cacheIndex = prevIndex; + actions[ prevIndex ] = lastActiveAction; + + }, + + // Memory management for PropertyMixer objects + + _addInactiveBinding: function ( binding, rootUuid, trackName ) { + + var bindingsByRoot = this._bindingsByRootAndName, + bindingByName = bindingsByRoot[ rootUuid ], + + bindings = this._bindings; + + if ( bindingByName === undefined ) { + + bindingByName = {}; + bindingsByRoot[ rootUuid ] = bindingByName; + + } + + bindingByName[ trackName ] = binding; + + binding._cacheIndex = bindings.length; + bindings.push( binding ); + + }, + + _removeInactiveBinding: function ( binding ) { + + var bindings = this._bindings, + propBinding = binding.binding, + rootUuid = propBinding.rootNode.uuid, + trackName = propBinding.path, + bindingsByRoot = this._bindingsByRootAndName, + bindingByName = bindingsByRoot[ rootUuid ], + + lastInactiveBinding = bindings[ bindings.length - 1 ], + cacheIndex = binding._cacheIndex; + + lastInactiveBinding._cacheIndex = cacheIndex; + bindings[ cacheIndex ] = lastInactiveBinding; + bindings.pop(); + + delete bindingByName[ trackName ]; + + remove_empty_map: { + + for ( var _ in bindingByName ) break remove_empty_map; // eslint-disable-line no-unused-vars + + delete bindingsByRoot[ rootUuid ]; + + } + + }, + + _lendBinding: function ( binding ) { + + var bindings = this._bindings, + prevIndex = binding._cacheIndex, + + lastActiveIndex = this._nActiveBindings ++, + + firstInactiveBinding = bindings[ lastActiveIndex ]; + + binding._cacheIndex = lastActiveIndex; + bindings[ lastActiveIndex ] = binding; + + firstInactiveBinding._cacheIndex = prevIndex; + bindings[ prevIndex ] = firstInactiveBinding; + + }, + + _takeBackBinding: function ( binding ) { + + var bindings = this._bindings, + prevIndex = binding._cacheIndex, + + firstInactiveIndex = -- this._nActiveBindings, + + lastActiveBinding = bindings[ firstInactiveIndex ]; + + binding._cacheIndex = firstInactiveIndex; + bindings[ firstInactiveIndex ] = binding; + + lastActiveBinding._cacheIndex = prevIndex; + bindings[ prevIndex ] = lastActiveBinding; + + }, + + + // Memory management of Interpolants for weight and time scale + + _lendControlInterpolant: function () { + + var interpolants = this._controlInterpolants, + lastActiveIndex = this._nActiveControlInterpolants ++, + interpolant = interpolants[ lastActiveIndex ]; + + if ( interpolant === undefined ) { + + interpolant = new LinearInterpolant( + new Float32Array( 2 ), new Float32Array( 2 ), + 1, this._controlInterpolantsResultBuffer ); + + interpolant.__cacheIndex = lastActiveIndex; + interpolants[ lastActiveIndex ] = interpolant; + + } + + return interpolant; + + }, + + _takeBackControlInterpolant: function ( interpolant ) { + + var interpolants = this._controlInterpolants, + prevIndex = interpolant.__cacheIndex, + + firstInactiveIndex = -- this._nActiveControlInterpolants, + + lastActiveInterpolant = interpolants[ firstInactiveIndex ]; + + interpolant.__cacheIndex = firstInactiveIndex; + interpolants[ firstInactiveIndex ] = interpolant; + + lastActiveInterpolant.__cacheIndex = prevIndex; + interpolants[ prevIndex ] = lastActiveInterpolant; + + }, + + _controlInterpolantsResultBuffer: new Float32Array( 1 ), + + // return an action for a clip optionally using a custom root target + // object (this method allocates a lot of dynamic memory in case a + // previously unknown clip/root combination is specified) + clipAction: function ( clip, optionalRoot ) { + + var root = optionalRoot || this._root, + rootUuid = root.uuid, + + clipObject = typeof clip === 'string' ? + AnimationClip.findByName( root, clip ) : clip, + + clipUuid = clipObject !== null ? clipObject.uuid : clip, + + actionsForClip = this._actionsByClip[ clipUuid ], + prototypeAction = null; + + if ( actionsForClip !== undefined ) { + + var existingAction = + actionsForClip.actionByRoot[ rootUuid ]; + + if ( existingAction !== undefined ) { + + return existingAction; + + } + + // we know the clip, so we don't have to parse all + // the bindings again but can just copy + prototypeAction = actionsForClip.knownActions[ 0 ]; + + // also, take the clip from the prototype action + if ( clipObject === null ) + clipObject = prototypeAction._clip; + + } + + // clip must be known when specified via string + if ( clipObject === null ) return null; + + // allocate all resources required to run it + var newAction = new AnimationAction( this, clipObject, optionalRoot ); + + this._bindAction( newAction, prototypeAction ); + + // and make the action known to the memory manager + this._addInactiveAction( newAction, clipUuid, rootUuid ); + + return newAction; + + }, + + // get an existing action + existingAction: function ( clip, optionalRoot ) { + + var root = optionalRoot || this._root, + rootUuid = root.uuid, + + clipObject = typeof clip === 'string' ? + AnimationClip.findByName( root, clip ) : clip, + + clipUuid = clipObject ? clipObject.uuid : clip, + + actionsForClip = this._actionsByClip[ clipUuid ]; + + if ( actionsForClip !== undefined ) { + + return actionsForClip.actionByRoot[ rootUuid ] || null; + + } + + return null; + + }, + + // deactivates all previously scheduled actions + stopAllAction: function () { + + var actions = this._actions, + nActions = this._nActiveActions, + bindings = this._bindings, + nBindings = this._nActiveBindings; + + this._nActiveActions = 0; + this._nActiveBindings = 0; + + for ( var i = 0; i !== nActions; ++ i ) { + + actions[ i ].reset(); + + } + + for ( var i = 0; i !== nBindings; ++ i ) { + + bindings[ i ].useCount = 0; + + } + + return this; + + }, + + // advance the time and update apply the animation + update: function ( deltaTime ) { + + deltaTime *= this.timeScale; + + var actions = this._actions, + nActions = this._nActiveActions, + + time = this.time += deltaTime, + timeDirection = Math.sign( deltaTime ), + + accuIndex = this._accuIndex ^= 1; + + // run active actions + + for ( var i = 0; i !== nActions; ++ i ) { + + var action = actions[ i ]; + + action._update( time, deltaTime, timeDirection, accuIndex ); + + } + + // update scene graph + + var bindings = this._bindings, + nBindings = this._nActiveBindings; + + for ( var i = 0; i !== nBindings; ++ i ) { + + bindings[ i ].apply( accuIndex ); + + } + + return this; + + }, + + // return this mixer's root target object + getRoot: function () { + + return this._root; + + }, + + // free all resources specific to a particular clip + uncacheClip: function ( clip ) { + + var actions = this._actions, + clipUuid = clip.uuid, + actionsByClip = this._actionsByClip, + actionsForClip = actionsByClip[ clipUuid ]; + + if ( actionsForClip !== undefined ) { + + // note: just calling _removeInactiveAction would mess up the + // iteration state and also require updating the state we can + // just throw away + + var actionsToRemove = actionsForClip.knownActions; + + for ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) { + + var action = actionsToRemove[ i ]; + + this._deactivateAction( action ); + + var cacheIndex = action._cacheIndex, + lastInactiveAction = actions[ actions.length - 1 ]; + + action._cacheIndex = null; + action._byClipCacheIndex = null; + + lastInactiveAction._cacheIndex = cacheIndex; + actions[ cacheIndex ] = lastInactiveAction; + actions.pop(); + + this._removeInactiveBindingsForAction( action ); + + } + + delete actionsByClip[ clipUuid ]; + + } + + }, + + // free all resources specific to a particular root target object + uncacheRoot: function ( root ) { + + var rootUuid = root.uuid, + actionsByClip = this._actionsByClip; + + for ( var clipUuid in actionsByClip ) { + + var actionByRoot = actionsByClip[ clipUuid ].actionByRoot, + action = actionByRoot[ rootUuid ]; + + if ( action !== undefined ) { + + this._deactivateAction( action ); + this._removeInactiveAction( action ); + + } + + } + + var bindingsByRoot = this._bindingsByRootAndName, + bindingByName = bindingsByRoot[ rootUuid ]; + + if ( bindingByName !== undefined ) { + + for ( var trackName in bindingByName ) { + + var binding = bindingByName[ trackName ]; + binding.restoreOriginalState(); + this._removeInactiveBinding( binding ); + + } + + } + + }, + + // remove a targeted clip from the cache + uncacheAction: function ( clip, optionalRoot ) { + + var action = this.existingAction( clip, optionalRoot ); + + if ( action !== null ) { + + this._deactivateAction( action ); + this._removeInactiveAction( action ); + + } + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Uniform( value ) { + + if ( typeof value === 'string' ) { + + console.warn( 'THREE.Uniform: Type parameter is no longer needed.' ); + value = arguments[ 1 ]; + + } + + this.value = value; + + } + + Uniform.prototype.clone = function () { + + return new Uniform( this.value.clone === undefined ? this.value : this.value.clone() ); + + }; + + /** + * @author benaadams / https://twitter.com/ben_a_adams + */ + + function InstancedBufferGeometry() { + + BufferGeometry.call( this ); + + this.type = 'InstancedBufferGeometry'; + this.maxInstancedCount = undefined; + + } + + InstancedBufferGeometry.prototype = Object.assign( Object.create( BufferGeometry.prototype ), { + + constructor: InstancedBufferGeometry, + + isInstancedBufferGeometry: true, + + copy: function ( source ) { + + BufferGeometry.prototype.copy.call( this, source ); + + this.maxInstancedCount = source.maxInstancedCount; + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + } + + } ); + + /** + * @author benaadams / https://twitter.com/ben_a_adams + */ + + function InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, normalized ) { + + this.uuid = _Math.generateUUID(); + + this.data = interleavedBuffer; + this.itemSize = itemSize; + this.offset = offset; + + this.normalized = normalized === true; + + } + + Object.defineProperties( InterleavedBufferAttribute.prototype, { + + count: { + + get: function () { + + return this.data.count; + + } + + }, + + array: { + + get: function () { + + return this.data.array; + + } + + } + + } ); + + Object.assign( InterleavedBufferAttribute.prototype, { + + isInterleavedBufferAttribute: true, + + setX: function ( index, x ) { + + this.data.array[ index * this.data.stride + this.offset ] = x; + + return this; + + }, + + setY: function ( index, y ) { + + this.data.array[ index * this.data.stride + this.offset + 1 ] = y; + + return this; + + }, + + setZ: function ( index, z ) { + + this.data.array[ index * this.data.stride + this.offset + 2 ] = z; + + return this; + + }, + + setW: function ( index, w ) { + + this.data.array[ index * this.data.stride + this.offset + 3 ] = w; + + return this; + + }, + + getX: function ( index ) { + + return this.data.array[ index * this.data.stride + this.offset ]; + + }, + + getY: function ( index ) { + + return this.data.array[ index * this.data.stride + this.offset + 1 ]; + + }, + + getZ: function ( index ) { + + return this.data.array[ index * this.data.stride + this.offset + 2 ]; + + }, + + getW: function ( index ) { + + return this.data.array[ index * this.data.stride + this.offset + 3 ]; + + }, + + setXY: function ( index, x, y ) { + + index = index * this.data.stride + this.offset; + + this.data.array[ index + 0 ] = x; + this.data.array[ index + 1 ] = y; + + return this; + + }, + + setXYZ: function ( index, x, y, z ) { + + index = index * this.data.stride + this.offset; + + this.data.array[ index + 0 ] = x; + this.data.array[ index + 1 ] = y; + this.data.array[ index + 2 ] = z; + + return this; + + }, + + setXYZW: function ( index, x, y, z, w ) { + + index = index * this.data.stride + this.offset; + + this.data.array[ index + 0 ] = x; + this.data.array[ index + 1 ] = y; + this.data.array[ index + 2 ] = z; + this.data.array[ index + 3 ] = w; + + return this; + + } + + } ); + + /** + * @author benaadams / https://twitter.com/ben_a_adams + */ + + function InterleavedBuffer( array, stride ) { + + this.uuid = _Math.generateUUID(); + + this.array = array; + this.stride = stride; + this.count = array !== undefined ? array.length / stride : 0; + + this.dynamic = false; + this.updateRange = { offset: 0, count: - 1 }; + + this.onUploadCallback = function () {}; + + this.version = 0; + + } + + Object.defineProperty( InterleavedBuffer.prototype, 'needsUpdate', { + + set: function ( value ) { + + if ( value === true ) this.version ++; + + } + + } ); + + Object.assign( InterleavedBuffer.prototype, { + + isInterleavedBuffer: true, + + setArray: function ( array ) { + + if ( Array.isArray( array ) ) { + + throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' ); + + } + + this.count = array !== undefined ? array.length / this.stride : 0; + this.array = array; + + }, + + setDynamic: function ( value ) { + + this.dynamic = value; + + return this; + + }, + + copy: function ( source ) { + + this.array = new source.array.constructor( source.array ); + this.count = source.count; + this.stride = source.stride; + this.dynamic = source.dynamic; + + return this; + + }, + + copyAt: function ( index1, attribute, index2 ) { + + index1 *= this.stride; + index2 *= attribute.stride; + + for ( var i = 0, l = this.stride; i < l; i ++ ) { + + this.array[ index1 + i ] = attribute.array[ index2 + i ]; + + } + + return this; + + }, + + set: function ( value, offset ) { + + if ( offset === undefined ) offset = 0; + + this.array.set( value, offset ); + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + onUpload: function ( callback ) { + + this.onUploadCallback = callback; + + return this; + + } + + } ); + + /** + * @author benaadams / https://twitter.com/ben_a_adams + */ + + function InstancedInterleavedBuffer( array, stride, meshPerAttribute ) { + + InterleavedBuffer.call( this, array, stride ); + + this.meshPerAttribute = meshPerAttribute || 1; + + } + + InstancedInterleavedBuffer.prototype = Object.assign( Object.create( InterleavedBuffer.prototype ), { + + constructor: InstancedInterleavedBuffer, + + isInstancedInterleavedBuffer: true, + + copy: function ( source ) { + + InterleavedBuffer.prototype.copy.call( this, source ); + + this.meshPerAttribute = source.meshPerAttribute; + + return this; + + } + + } ); + + /** + * @author benaadams / https://twitter.com/ben_a_adams + */ + + function InstancedBufferAttribute( array, itemSize, meshPerAttribute ) { + + BufferAttribute.call( this, array, itemSize ); + + this.meshPerAttribute = meshPerAttribute || 1; + + } + + InstancedBufferAttribute.prototype = Object.assign( Object.create( BufferAttribute.prototype ), { + + constructor: InstancedBufferAttribute, + + isInstancedBufferAttribute: true, + + copy: function ( source ) { + + BufferAttribute.prototype.copy.call( this, source ); + + this.meshPerAttribute = source.meshPerAttribute; + + return this; + + } + + } ); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author bhouston / http://clara.io/ + * @author stephomi / http://stephaneginier.com/ + */ + + function Raycaster( origin, direction, near, far ) { + + this.ray = new Ray( origin, direction ); + // direction is assumed to be normalized (for accurate distance calculations) + + this.near = near || 0; + this.far = far || Infinity; + + this.params = { + Mesh: {}, + Line: {}, + LOD: {}, + Points: { threshold: 1 }, + Sprite: {} + }; + + Object.defineProperties( this.params, { + PointCloud: { + get: function () { + + console.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' ); + return this.Points; + + } + } + } ); + + } + + function ascSort( a, b ) { + + return a.distance - b.distance; + + } + + function intersectObject( object, raycaster, intersects, recursive ) { + + if ( object.visible === false ) return; + + object.raycast( raycaster, intersects ); + + if ( recursive === true ) { + + var children = object.children; + + for ( var i = 0, l = children.length; i < l; i ++ ) { + + intersectObject( children[ i ], raycaster, intersects, true ); + + } + + } + + } + + Object.assign( Raycaster.prototype, { + + linePrecision: 1, + + set: function ( origin, direction ) { + + // direction is assumed to be normalized (for accurate distance calculations) + + this.ray.set( origin, direction ); + + }, + + setFromCamera: function ( coords, camera ) { + + if ( ( camera && camera.isPerspectiveCamera ) ) { + + this.ray.origin.setFromMatrixPosition( camera.matrixWorld ); + this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize(); + + } else if ( ( camera && camera.isOrthographicCamera ) ) { + + this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera + this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld ); + + } else { + + console.error( 'THREE.Raycaster: Unsupported camera type.' ); + + } + + }, + + intersectObject: function ( object, recursive ) { + + var intersects = []; + + intersectObject( object, this, intersects, recursive ); + + intersects.sort( ascSort ); + + return intersects; + + }, + + intersectObjects: function ( objects, recursive ) { + + var intersects = []; + + if ( Array.isArray( objects ) === false ) { + + console.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' ); + return intersects; + + } + + for ( var i = 0, l = objects.length; i < l; i ++ ) { + + intersectObject( objects[ i ], this, intersects, recursive ); + + } + + intersects.sort( ascSort ); + + return intersects; + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function Clock( autoStart ) { + + this.autoStart = ( autoStart !== undefined ) ? autoStart : true; + + this.startTime = 0; + this.oldTime = 0; + this.elapsedTime = 0; + + this.running = false; + + } + + Object.assign( Clock.prototype, { + + start: function () { + + this.startTime = ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732 + + this.oldTime = this.startTime; + this.elapsedTime = 0; + this.running = true; + + }, + + stop: function () { + + this.getElapsedTime(); + this.running = false; + this.autoStart = false; + + }, + + getElapsedTime: function () { + + this.getDelta(); + return this.elapsedTime; + + }, + + getDelta: function () { + + var diff = 0; + + if ( this.autoStart && ! this.running ) { + + this.start(); + return 0; + + } + + if ( this.running ) { + + var newTime = ( typeof performance === 'undefined' ? Date : performance ).now(); + + diff = ( newTime - this.oldTime ) / 1000; + this.oldTime = newTime; + + this.elapsedTime += diff; + + } + + return diff; + + } + + } ); + + /** + * @author bhouston / http://clara.io + * @author WestLangley / http://github.com/WestLangley + * + * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system + * + * The poles (phi) are at the positive and negative y axis. + * The equator starts at positive z. + */ + + function Spherical( radius, phi, theta ) { + + this.radius = ( radius !== undefined ) ? radius : 1.0; + this.phi = ( phi !== undefined ) ? phi : 0; // up / down towards top and bottom pole + this.theta = ( theta !== undefined ) ? theta : 0; // around the equator of the sphere + + return this; + + } + + Object.assign( Spherical.prototype, { + + set: function ( radius, phi, theta ) { + + this.radius = radius; + this.phi = phi; + this.theta = theta; + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( other ) { + + this.radius = other.radius; + this.phi = other.phi; + this.theta = other.theta; + + return this; + + }, + + // restrict phi to be betwee EPS and PI-EPS + makeSafe: function () { + + var EPS = 0.000001; + this.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) ); + + return this; + + }, + + setFromVector3: function ( vec3 ) { + + this.radius = vec3.length(); + + if ( this.radius === 0 ) { + + this.theta = 0; + this.phi = 0; + + } else { + + this.theta = Math.atan2( vec3.x, vec3.z ); // equator angle around y-up axis + this.phi = Math.acos( _Math.clamp( vec3.y / this.radius, - 1, 1 ) ); // polar angle + + } + + return this; + + } + + } ); + + /** + * @author Mugen87 / https://github.com/Mugen87 + * + * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system + * + */ + + function Cylindrical( radius, theta, y ) { + + this.radius = ( radius !== undefined ) ? radius : 1.0; // distance from the origin to a point in the x-z plane + this.theta = ( theta !== undefined ) ? theta : 0; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis + this.y = ( y !== undefined ) ? y : 0; // height above the x-z plane + + return this; + + } + + Object.assign( Cylindrical.prototype, { + + set: function ( radius, theta, y ) { + + this.radius = radius; + this.theta = theta; + this.y = y; + + return this; + + }, + + clone: function () { + + return new this.constructor().copy( this ); + + }, + + copy: function ( other ) { + + this.radius = other.radius; + this.theta = other.theta; + this.y = other.y; + + return this; + + }, + + setFromVector3: function ( vec3 ) { + + this.radius = Math.sqrt( vec3.x * vec3.x + vec3.z * vec3.z ); + this.theta = Math.atan2( vec3.x, vec3.z ); + this.y = vec3.y; + + return this; + + } + + } ); + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + function ImmediateRenderObject( material ) { + + Object3D.call( this ); + + this.material = material; + this.render = function ( /* renderCallback */ ) {}; + + } + + ImmediateRenderObject.prototype = Object.create( Object3D.prototype ); + ImmediateRenderObject.prototype.constructor = ImmediateRenderObject; + + ImmediateRenderObject.prototype.isImmediateRenderObject = true; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function VertexNormalsHelper( object, size, hex, linewidth ) { + + this.object = object; + + this.size = ( size !== undefined ) ? size : 1; + + var color = ( hex !== undefined ) ? hex : 0xff0000; + + var width = ( linewidth !== undefined ) ? linewidth : 1; + + // + + var nNormals = 0; + + var objGeometry = this.object.geometry; + + if ( objGeometry && objGeometry.isGeometry ) { + + nNormals = objGeometry.faces.length * 3; + + } else if ( objGeometry && objGeometry.isBufferGeometry ) { + + nNormals = objGeometry.attributes.normal.count; + + } + + // + + var geometry = new BufferGeometry(); + + var positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 ); + + geometry.addAttribute( 'position', positions ); + + LineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) ); + + // + + this.matrixAutoUpdate = false; + + this.update(); + + } + + VertexNormalsHelper.prototype = Object.create( LineSegments.prototype ); + VertexNormalsHelper.prototype.constructor = VertexNormalsHelper; + + VertexNormalsHelper.prototype.update = ( function () { + + var v1 = new Vector3(); + var v2 = new Vector3(); + var normalMatrix = new Matrix3(); + + return function update() { + + var keys = [ 'a', 'b', 'c' ]; + + this.object.updateMatrixWorld( true ); + + normalMatrix.getNormalMatrix( this.object.matrixWorld ); + + var matrixWorld = this.object.matrixWorld; + + var position = this.geometry.attributes.position; + + // + + var objGeometry = this.object.geometry; + + if ( objGeometry && objGeometry.isGeometry ) { + + var vertices = objGeometry.vertices; + + var faces = objGeometry.faces; + + var idx = 0; + + for ( var i = 0, l = faces.length; i < l; i ++ ) { + + var face = faces[ i ]; + + for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) { + + var vertex = vertices[ face[ keys[ j ] ] ]; + + var normal = face.vertexNormals[ j ]; + + v1.copy( vertex ).applyMatrix4( matrixWorld ); + + v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 ); + + position.setXYZ( idx, v1.x, v1.y, v1.z ); + + idx = idx + 1; + + position.setXYZ( idx, v2.x, v2.y, v2.z ); + + idx = idx + 1; + + } + + } + + } else if ( objGeometry && objGeometry.isBufferGeometry ) { + + var objPos = objGeometry.attributes.position; + + var objNorm = objGeometry.attributes.normal; + + var idx = 0; + + // for simplicity, ignore index and drawcalls, and render every normal + + for ( var j = 0, jl = objPos.count; j < jl; j ++ ) { + + v1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld ); + + v2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) ); + + v2.applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 ); + + position.setXYZ( idx, v1.x, v1.y, v1.z ); + + idx = idx + 1; + + position.setXYZ( idx, v2.x, v2.y, v2.z ); + + idx = idx + 1; + + } + + } + + position.needsUpdate = true; + + }; + + }() ); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function SpotLightHelper( light, color ) { + + Object3D.call( this ); + + this.light = light; + this.light.updateMatrixWorld(); + + this.matrix = light.matrixWorld; + this.matrixAutoUpdate = false; + + this.color = color; + + var geometry = new BufferGeometry(); + + var positions = [ + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 1, + 0, 0, 0, - 1, 0, 1, + 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, - 1, 1 + ]; + + for ( var i = 0, j = 1, l = 32; i < l; i ++, j ++ ) { + + var p1 = ( i / l ) * Math.PI * 2; + var p2 = ( j / l ) * Math.PI * 2; + + positions.push( + Math.cos( p1 ), Math.sin( p1 ), 1, + Math.cos( p2 ), Math.sin( p2 ), 1 + ); + + } + + geometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) ); + + var material = new LineBasicMaterial( { fog: false } ); + + this.cone = new LineSegments( geometry, material ); + this.add( this.cone ); + + this.update(); + + } + + SpotLightHelper.prototype = Object.create( Object3D.prototype ); + SpotLightHelper.prototype.constructor = SpotLightHelper; + + SpotLightHelper.prototype.dispose = function () { + + this.cone.geometry.dispose(); + this.cone.material.dispose(); + + }; + + SpotLightHelper.prototype.update = function () { + + var vector = new Vector3(); + var vector2 = new Vector3(); + + return function update() { + + this.light.updateMatrixWorld(); + + var coneLength = this.light.distance ? this.light.distance : 1000; + var coneWidth = coneLength * Math.tan( this.light.angle ); + + this.cone.scale.set( coneWidth, coneWidth, coneLength ); + + vector.setFromMatrixPosition( this.light.matrixWorld ); + vector2.setFromMatrixPosition( this.light.target.matrixWorld ); + + this.cone.lookAt( vector2.sub( vector ) ); + + if ( this.color !== undefined ) { + + this.cone.material.color.set( this.color ); + + } else { + + this.cone.material.color.copy( this.light.color ); + + } + + }; + + }(); + + /** + * @author Sean Griffin / http://twitter.com/sgrif + * @author Michael Guerrero / http://realitymeltdown.com + * @author mrdoob / http://mrdoob.com/ + * @author ikerr / http://verold.com + * @author Mugen87 / https://github.com/Mugen87 + */ + + function getBoneList( object ) { + + var boneList = []; + + if ( object && object.isBone ) { + + boneList.push( object ); + + } + + for ( var i = 0; i < object.children.length; i ++ ) { + + boneList.push.apply( boneList, getBoneList( object.children[ i ] ) ); + + } + + return boneList; + + } + + function SkeletonHelper( object ) { + + var bones = getBoneList( object ); + + var geometry = new BufferGeometry(); + + var vertices = []; + var colors = []; + + var color1 = new Color( 0, 0, 1 ); + var color2 = new Color( 0, 1, 0 ); + + for ( var i = 0; i < bones.length; i ++ ) { + + var bone = bones[ i ]; + + if ( bone.parent && bone.parent.isBone ) { + + vertices.push( 0, 0, 0 ); + vertices.push( 0, 0, 0 ); + colors.push( color1.r, color1.g, color1.b ); + colors.push( color2.r, color2.g, color2.b ); + + } + + } + + geometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + geometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) ); + + var material = new LineBasicMaterial( { vertexColors: VertexColors, depthTest: false, depthWrite: false, transparent: true } ); + + LineSegments.call( this, geometry, material ); + + this.root = object; + this.bones = bones; + + this.matrix = object.matrixWorld; + this.matrixAutoUpdate = false; + + } + + SkeletonHelper.prototype = Object.create( LineSegments.prototype ); + SkeletonHelper.prototype.constructor = SkeletonHelper; + + SkeletonHelper.prototype.updateMatrixWorld = function () { + + var vector = new Vector3(); + + var boneMatrix = new Matrix4(); + var matrixWorldInv = new Matrix4(); + + return function updateMatrixWorld( force ) { + + var bones = this.bones; + + var geometry = this.geometry; + var position = geometry.getAttribute( 'position' ); + + matrixWorldInv.getInverse( this.root.matrixWorld ); + + for ( var i = 0, j = 0; i < bones.length; i ++ ) { + + var bone = bones[ i ]; + + if ( bone.parent && bone.parent.isBone ) { + + boneMatrix.multiplyMatrices( matrixWorldInv, bone.matrixWorld ); + vector.setFromMatrixPosition( boneMatrix ); + position.setXYZ( j, vector.x, vector.y, vector.z ); + + boneMatrix.multiplyMatrices( matrixWorldInv, bone.parent.matrixWorld ); + vector.setFromMatrixPosition( boneMatrix ); + position.setXYZ( j + 1, vector.x, vector.y, vector.z ); + + j += 2; + + } + + } + + geometry.getAttribute( 'position' ).needsUpdate = true; + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + }; + + }(); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + */ + + function PointLightHelper( light, sphereSize, color ) { + + this.light = light; + this.light.updateMatrixWorld(); + + this.color = color; + + var geometry = new SphereBufferGeometry( sphereSize, 4, 2 ); + var material = new MeshBasicMaterial( { wireframe: true, fog: false } ); + + Mesh.call( this, geometry, material ); + + this.matrix = this.light.matrixWorld; + this.matrixAutoUpdate = false; + + this.update(); + + + /* + var distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 ); + var distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } ); + + this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial ); + this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial ); + + var d = light.distance; + + if ( d === 0.0 ) { + + this.lightDistance.visible = false; + + } else { + + this.lightDistance.scale.set( d, d, d ); + + } + + this.add( this.lightDistance ); + */ + + } + + PointLightHelper.prototype = Object.create( Mesh.prototype ); + PointLightHelper.prototype.constructor = PointLightHelper; + + PointLightHelper.prototype.dispose = function () { + + this.geometry.dispose(); + this.material.dispose(); + + }; + + PointLightHelper.prototype.update = function () { + + if ( this.color !== undefined ) { + + this.material.color.set( this.color ); + + } else { + + this.material.color.copy( this.light.color ); + + } + + /* + var d = this.light.distance; + + if ( d === 0.0 ) { + + this.lightDistance.visible = false; + + } else { + + this.lightDistance.visible = true; + this.lightDistance.scale.set( d, d, d ); + + } + */ + + }; + + /** + * @author abelnation / http://github.com/abelnation + * @author Mugen87 / http://github.com/Mugen87 + * @author WestLangley / http://github.com/WestLangley + */ + + function RectAreaLightHelper( light, color ) { + + Object3D.call( this ); + + this.light = light; + this.light.updateMatrixWorld(); + + this.matrix = light.matrixWorld; + this.matrixAutoUpdate = false; + + this.color = color; + + var material = new LineBasicMaterial( { fog: false } ); + + var geometry = new BufferGeometry(); + + geometry.addAttribute( 'position', new BufferAttribute( new Float32Array( 5 * 3 ), 3 ) ); + + this.line = new Line( geometry, material ); + this.add( this.line ); + + + this.update(); + + } + + RectAreaLightHelper.prototype = Object.create( Object3D.prototype ); + RectAreaLightHelper.prototype.constructor = RectAreaLightHelper; + + RectAreaLightHelper.prototype.dispose = function () { + + this.children[ 0 ].geometry.dispose(); + this.children[ 0 ].material.dispose(); + + }; + + RectAreaLightHelper.prototype.update = function () { + + // calculate new dimensions of the helper + + var hx = this.light.width * 0.5; + var hy = this.light.height * 0.5; + + var position = this.line.geometry.attributes.position; + var array = position.array; + + // update vertices + + array[ 0 ] = hx; array[ 1 ] = - hy; array[ 2 ] = 0; + array[ 3 ] = hx; array[ 4 ] = hy; array[ 5 ] = 0; + array[ 6 ] = - hx; array[ 7 ] = hy; array[ 8 ] = 0; + array[ 9 ] = - hx; array[ 10 ] = - hy; array[ 11 ] = 0; + array[ 12 ] = hx; array[ 13 ] = - hy; array[ 14 ] = 0; + + position.needsUpdate = true; + + if ( this.color !== undefined ) { + + this.line.material.color.set( this.color ); + + } else { + + this.line.material.color.copy( this.light.color ); + + } + + }; + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + + function HemisphereLightHelper( light, size, color ) { + + Object3D.call( this ); + + this.light = light; + this.light.updateMatrixWorld(); + + this.matrix = light.matrixWorld; + this.matrixAutoUpdate = false; + + this.color = color; + + var geometry = new OctahedronBufferGeometry( size ); + geometry.rotateY( Math.PI * 0.5 ); + + this.material = new MeshBasicMaterial( { wireframe: true, fog: false } ); + if ( this.color === undefined ) this.material.vertexColors = VertexColors; + + var position = geometry.getAttribute( 'position' ); + var colors = new Float32Array( position.count * 3 ); + + geometry.addAttribute( 'color', new BufferAttribute( colors, 3 ) ); + + this.add( new Mesh( geometry, this.material ) ); + + this.update(); + + } + + HemisphereLightHelper.prototype = Object.create( Object3D.prototype ); + HemisphereLightHelper.prototype.constructor = HemisphereLightHelper; + + HemisphereLightHelper.prototype.dispose = function () { + + this.children[ 0 ].geometry.dispose(); + this.children[ 0 ].material.dispose(); + + }; + + HemisphereLightHelper.prototype.update = function () { + + var vector = new Vector3(); + + var color1 = new Color(); + var color2 = new Color(); + + return function update() { + + var mesh = this.children[ 0 ]; + + if ( this.color !== undefined ) { + + this.material.color.set( this.color ); + + } else { + + var colors = mesh.geometry.getAttribute( 'color' ); + + color1.copy( this.light.color ); + color2.copy( this.light.groundColor ); + + for ( var i = 0, l = colors.count; i < l; i ++ ) { + + var color = ( i < ( l / 2 ) ) ? color1 : color2; + + colors.setXYZ( i, color.r, color.g, color.b ); + + } + + colors.needsUpdate = true; + + } + + mesh.lookAt( vector.setFromMatrixPosition( this.light.matrixWorld ).negate() ); + + }; + + }(); + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function GridHelper( size, divisions, color1, color2 ) { + + size = size || 10; + divisions = divisions || 10; + color1 = new Color( color1 !== undefined ? color1 : 0x444444 ); + color2 = new Color( color2 !== undefined ? color2 : 0x888888 ); + + var center = divisions / 2; + var step = size / divisions; + var halfSize = size / 2; + + var vertices = [], colors = []; + + for ( var i = 0, j = 0, k = - halfSize; i <= divisions; i ++, k += step ) { + + vertices.push( - halfSize, 0, k, halfSize, 0, k ); + vertices.push( k, 0, - halfSize, k, 0, halfSize ); + + var color = i === center ? color1 : color2; + + color.toArray( colors, j ); j += 3; + color.toArray( colors, j ); j += 3; + color.toArray( colors, j ); j += 3; + color.toArray( colors, j ); j += 3; + + } + + var geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + geometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) ); + + var material = new LineBasicMaterial( { vertexColors: VertexColors } ); + + LineSegments.call( this, geometry, material ); + + } + + GridHelper.prototype = Object.create( LineSegments.prototype ); + GridHelper.prototype.constructor = GridHelper; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / http://github.com/Mugen87 + * @author Hectate / http://www.github.com/Hectate + */ + + function PolarGridHelper( radius, radials, circles, divisions, color1, color2 ) { + + radius = radius || 10; + radials = radials || 16; + circles = circles || 8; + divisions = divisions || 64; + color1 = new Color( color1 !== undefined ? color1 : 0x444444 ); + color2 = new Color( color2 !== undefined ? color2 : 0x888888 ); + + var vertices = []; + var colors = []; + + var x, z; + var v, i, j, r, color; + + // create the radials + + for ( i = 0; i <= radials; i ++ ) { + + v = ( i / radials ) * ( Math.PI * 2 ); + + x = Math.sin( v ) * radius; + z = Math.cos( v ) * radius; + + vertices.push( 0, 0, 0 ); + vertices.push( x, 0, z ); + + color = ( i & 1 ) ? color1 : color2; + + colors.push( color.r, color.g, color.b ); + colors.push( color.r, color.g, color.b ); + + } + + // create the circles + + for ( i = 0; i <= circles; i ++ ) { + + color = ( i & 1 ) ? color1 : color2; + + r = radius - ( radius / circles * i ); + + for ( j = 0; j < divisions; j ++ ) { + + // first vertex + + v = ( j / divisions ) * ( Math.PI * 2 ); + + x = Math.sin( v ) * r; + z = Math.cos( v ) * r; + + vertices.push( x, 0, z ); + colors.push( color.r, color.g, color.b ); + + // second vertex + + v = ( ( j + 1 ) / divisions ) * ( Math.PI * 2 ); + + x = Math.sin( v ) * r; + z = Math.cos( v ) * r; + + vertices.push( x, 0, z ); + colors.push( color.r, color.g, color.b ); + + } + + } + + var geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + geometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) ); + + var material = new LineBasicMaterial( { vertexColors: VertexColors } ); + + LineSegments.call( this, geometry, material ); + + } + + PolarGridHelper.prototype = Object.create( LineSegments.prototype ); + PolarGridHelper.prototype.constructor = PolarGridHelper; + + /** + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function FaceNormalsHelper( object, size, hex, linewidth ) { + + // FaceNormalsHelper only supports THREE.Geometry + + this.object = object; + + this.size = ( size !== undefined ) ? size : 1; + + var color = ( hex !== undefined ) ? hex : 0xffff00; + + var width = ( linewidth !== undefined ) ? linewidth : 1; + + // + + var nNormals = 0; + + var objGeometry = this.object.geometry; + + if ( objGeometry && objGeometry.isGeometry ) { + + nNormals = objGeometry.faces.length; + + } else { + + console.warn( 'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.' ); + + } + + // + + var geometry = new BufferGeometry(); + + var positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 ); + + geometry.addAttribute( 'position', positions ); + + LineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) ); + + // + + this.matrixAutoUpdate = false; + this.update(); + + } + + FaceNormalsHelper.prototype = Object.create( LineSegments.prototype ); + FaceNormalsHelper.prototype.constructor = FaceNormalsHelper; + + FaceNormalsHelper.prototype.update = ( function () { + + var v1 = new Vector3(); + var v2 = new Vector3(); + var normalMatrix = new Matrix3(); + + return function update() { + + this.object.updateMatrixWorld( true ); + + normalMatrix.getNormalMatrix( this.object.matrixWorld ); + + var matrixWorld = this.object.matrixWorld; + + var position = this.geometry.attributes.position; + + // + + var objGeometry = this.object.geometry; + + var vertices = objGeometry.vertices; + + var faces = objGeometry.faces; + + var idx = 0; + + for ( var i = 0, l = faces.length; i < l; i ++ ) { + + var face = faces[ i ]; + + var normal = face.normal; + + v1.copy( vertices[ face.a ] ) + .add( vertices[ face.b ] ) + .add( vertices[ face.c ] ) + .divideScalar( 3 ) + .applyMatrix4( matrixWorld ); + + v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 ); + + position.setXYZ( idx, v1.x, v1.y, v1.z ); + + idx = idx + 1; + + position.setXYZ( idx, v2.x, v2.y, v2.z ); + + idx = idx + 1; + + } + + position.needsUpdate = true; + + }; + + }() ); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author mrdoob / http://mrdoob.com/ + * @author WestLangley / http://github.com/WestLangley + */ + + function DirectionalLightHelper( light, size, color ) { + + Object3D.call( this ); + + this.light = light; + this.light.updateMatrixWorld(); + + this.matrix = light.matrixWorld; + this.matrixAutoUpdate = false; + + this.color = color; + + if ( size === undefined ) size = 1; + + var geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( [ + - size, size, 0, + size, size, 0, + size, - size, 0, + - size, - size, 0, + - size, size, 0 + ], 3 ) ); + + var material = new LineBasicMaterial( { fog: false } ); + + this.lightPlane = new Line( geometry, material ); + this.add( this.lightPlane ); + + geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 0, 1 ], 3 ) ); + + this.targetLine = new Line( geometry, material ); + this.add( this.targetLine ); + + this.update(); + + } + + DirectionalLightHelper.prototype = Object.create( Object3D.prototype ); + DirectionalLightHelper.prototype.constructor = DirectionalLightHelper; + + DirectionalLightHelper.prototype.dispose = function () { + + this.lightPlane.geometry.dispose(); + this.lightPlane.material.dispose(); + this.targetLine.geometry.dispose(); + this.targetLine.material.dispose(); + + }; + + DirectionalLightHelper.prototype.update = function () { + + var v1 = new Vector3(); + var v2 = new Vector3(); + var v3 = new Vector3(); + + return function update() { + + v1.setFromMatrixPosition( this.light.matrixWorld ); + v2.setFromMatrixPosition( this.light.target.matrixWorld ); + v3.subVectors( v2, v1 ); + + this.lightPlane.lookAt( v3 ); + + if ( this.color !== undefined ) { + + this.lightPlane.material.color.set( this.color ); + this.targetLine.material.color.set( this.color ); + + } else { + + this.lightPlane.material.color.copy( this.light.color ); + this.targetLine.material.color.copy( this.light.color ); + + } + + this.targetLine.lookAt( v3 ); + this.targetLine.scale.z = v3.length(); + + }; + + }(); + + /** + * @author alteredq / http://alteredqualia.com/ + * @author Mugen87 / https://github.com/Mugen87 + * + * - shows frustum, line of sight and up of the camera + * - suitable for fast updates + * - based on frustum visualization in lightgl.js shadowmap example + * http://evanw.github.com/lightgl.js/tests/shadowmap.html + */ + + function CameraHelper( camera ) { + + var geometry = new BufferGeometry(); + var material = new LineBasicMaterial( { color: 0xffffff, vertexColors: FaceColors } ); + + var vertices = []; + var colors = []; + + var pointMap = {}; + + // colors + + var colorFrustum = new Color( 0xffaa00 ); + var colorCone = new Color( 0xff0000 ); + var colorUp = new Color( 0x00aaff ); + var colorTarget = new Color( 0xffffff ); + var colorCross = new Color( 0x333333 ); + + // near + + addLine( 'n1', 'n2', colorFrustum ); + addLine( 'n2', 'n4', colorFrustum ); + addLine( 'n4', 'n3', colorFrustum ); + addLine( 'n3', 'n1', colorFrustum ); + + // far + + addLine( 'f1', 'f2', colorFrustum ); + addLine( 'f2', 'f4', colorFrustum ); + addLine( 'f4', 'f3', colorFrustum ); + addLine( 'f3', 'f1', colorFrustum ); + + // sides + + addLine( 'n1', 'f1', colorFrustum ); + addLine( 'n2', 'f2', colorFrustum ); + addLine( 'n3', 'f3', colorFrustum ); + addLine( 'n4', 'f4', colorFrustum ); + + // cone + + addLine( 'p', 'n1', colorCone ); + addLine( 'p', 'n2', colorCone ); + addLine( 'p', 'n3', colorCone ); + addLine( 'p', 'n4', colorCone ); + + // up + + addLine( 'u1', 'u2', colorUp ); + addLine( 'u2', 'u3', colorUp ); + addLine( 'u3', 'u1', colorUp ); + + // target + + addLine( 'c', 't', colorTarget ); + addLine( 'p', 'c', colorCross ); + + // cross + + addLine( 'cn1', 'cn2', colorCross ); + addLine( 'cn3', 'cn4', colorCross ); + + addLine( 'cf1', 'cf2', colorCross ); + addLine( 'cf3', 'cf4', colorCross ); + + function addLine( a, b, color ) { + + addPoint( a, color ); + addPoint( b, color ); + + } + + function addPoint( id, color ) { + + vertices.push( 0, 0, 0 ); + colors.push( color.r, color.g, color.b ); + + if ( pointMap[ id ] === undefined ) { + + pointMap[ id ] = []; + + } + + pointMap[ id ].push( ( vertices.length / 3 ) - 1 ); + + } + + geometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + geometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) ); + + LineSegments.call( this, geometry, material ); + + this.camera = camera; + if ( this.camera.updateProjectionMatrix ) this.camera.updateProjectionMatrix(); + + this.matrix = camera.matrixWorld; + this.matrixAutoUpdate = false; + + this.pointMap = pointMap; + + this.update(); + + } + + CameraHelper.prototype = Object.create( LineSegments.prototype ); + CameraHelper.prototype.constructor = CameraHelper; + + CameraHelper.prototype.update = function () { + + var geometry, pointMap; + + var vector = new Vector3(); + var camera = new Camera(); + + function setPoint( point, x, y, z ) { + + vector.set( x, y, z ).unproject( camera ); + + var points = pointMap[ point ]; + + if ( points !== undefined ) { + + var position = geometry.getAttribute( 'position' ); + + for ( var i = 0, l = points.length; i < l; i ++ ) { + + position.setXYZ( points[ i ], vector.x, vector.y, vector.z ); + + } + + } + + } + + return function update() { + + geometry = this.geometry; + pointMap = this.pointMap; + + var w = 1, h = 1; + + // we need just camera projection matrix + // world matrix must be identity + + camera.projectionMatrix.copy( this.camera.projectionMatrix ); + + // center / target + + setPoint( 'c', 0, 0, - 1 ); + setPoint( 't', 0, 0, 1 ); + + // near + + setPoint( 'n1', - w, - h, - 1 ); + setPoint( 'n2', w, - h, - 1 ); + setPoint( 'n3', - w, h, - 1 ); + setPoint( 'n4', w, h, - 1 ); + + // far + + setPoint( 'f1', - w, - h, 1 ); + setPoint( 'f2', w, - h, 1 ); + setPoint( 'f3', - w, h, 1 ); + setPoint( 'f4', w, h, 1 ); + + // up + + setPoint( 'u1', w * 0.7, h * 1.1, - 1 ); + setPoint( 'u2', - w * 0.7, h * 1.1, - 1 ); + setPoint( 'u3', 0, h * 2, - 1 ); + + // cross + + setPoint( 'cf1', - w, 0, 1 ); + setPoint( 'cf2', w, 0, 1 ); + setPoint( 'cf3', 0, - h, 1 ); + setPoint( 'cf4', 0, h, 1 ); + + setPoint( 'cn1', - w, 0, - 1 ); + setPoint( 'cn2', w, 0, - 1 ); + setPoint( 'cn3', 0, - h, - 1 ); + setPoint( 'cn4', 0, h, - 1 ); + + geometry.getAttribute( 'position' ).needsUpdate = true; + + }; + + }(); + + /** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / http://github.com/Mugen87 + */ + + function BoxHelper( object, color ) { + + this.object = object; + + if ( color === undefined ) color = 0xffff00; + + var 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 ] ); + var positions = new Float32Array( 8 * 3 ); + + var geometry = new BufferGeometry(); + geometry.setIndex( new BufferAttribute( indices, 1 ) ); + geometry.addAttribute( 'position', new BufferAttribute( positions, 3 ) ); + + LineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) ); + + this.matrixAutoUpdate = false; + + this.update(); + + } + + BoxHelper.prototype = Object.create( LineSegments.prototype ); + BoxHelper.prototype.constructor = BoxHelper; + + BoxHelper.prototype.update = ( function () { + + var box = new Box3(); + + return function update( object ) { + + if ( object !== undefined ) { + + console.warn( 'THREE.BoxHelper: .update() has no longer arguments.' ); + + } + + if ( this.object !== undefined ) { + + box.setFromObject( this.object ); + + } + + if ( box.isEmpty() ) return; + + var min = box.min; + var max = box.max; + + /* + 5____4 + 1/___0/| + | 6__|_7 + 2/___3/ + + 0: max.x, max.y, max.z + 1: min.x, max.y, max.z + 2: min.x, min.y, max.z + 3: max.x, min.y, max.z + 4: max.x, max.y, min.z + 5: min.x, max.y, min.z + 6: min.x, min.y, min.z + 7: max.x, min.y, min.z + */ + + var position = this.geometry.attributes.position; + var array = position.array; + + array[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z; + array[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z; + array[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z; + array[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z; + array[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z; + array[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z; + array[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z; + array[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z; + + position.needsUpdate = true; + + this.geometry.computeBoundingSphere(); + + }; + + } )(); + + BoxHelper.prototype.setFromObject = function ( object ) { + + this.object = object; + this.update(); + + return this; + + }; + + /** + * @author WestLangley / http://github.com/WestLangley + */ + + function Box3Helper( box, hex ) { + + this.type = 'Box3Helper'; + + this.box = box; + + var color = ( hex !== undefined ) ? hex : 0xffff00; + + var 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 ] ); + + var 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 ]; + + var geometry = new BufferGeometry(); + + geometry.setIndex( new BufferAttribute( indices, 1 ) ); + + geometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) ); + + LineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) ); + + this.geometry.computeBoundingSphere(); + + } + + Box3Helper.prototype = Object.create( LineSegments.prototype ); + Box3Helper.prototype.constructor = Box3Helper; + + Box3Helper.prototype.updateMatrixWorld = function ( force ) { + + var box = this.box; + + if ( box.isEmpty() ) return; + + box.getCenter( this.position ); + + box.getSize( this.scale ); + + this.scale.multiplyScalar( 0.5 ); + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + }; + + /** + * @author WestLangley / http://github.com/WestLangley + */ + + function PlaneHelper( plane, size, hex ) { + + this.type = 'PlaneHelper'; + + this.plane = plane; + + this.size = ( size === undefined ) ? 1 : size; + + var color = ( hex !== undefined ) ? hex : 0xffff00; + + var 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 ]; + + var geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) ); + geometry.computeBoundingSphere(); + + Line.call( this, geometry, new LineBasicMaterial( { color: color } ) ); + + // + + var positions2 = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, 1, 1, - 1, - 1, 1, 1, - 1, 1 ]; + + var geometry2 = new BufferGeometry(); + geometry2.addAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) ); + geometry2.computeBoundingSphere(); + + this.add( new Mesh( geometry2, new MeshBasicMaterial( { color: color, opacity: 0.2, transparent: true, depthWrite: false } ) ) ); + + } + + PlaneHelper.prototype = Object.create( Line.prototype ); + PlaneHelper.prototype.constructor = PlaneHelper; + + PlaneHelper.prototype.updateMatrixWorld = function ( force ) { + + var scale = - this.plane.constant; + + if ( Math.abs( scale ) < 1e-8 ) scale = 1e-8; // sign does not matter + + this.scale.set( 0.5 * this.size, 0.5 * this.size, scale ); + + this.lookAt( this.plane.normal ); + + Object3D.prototype.updateMatrixWorld.call( this, force ); + + }; + + /** + * @author WestLangley / http://github.com/WestLangley + * @author zz85 / http://github.com/zz85 + * @author bhouston / http://clara.io + * + * Creates an arrow for visualizing directions + * + * Parameters: + * dir - Vector3 + * origin - Vector3 + * length - Number + * color - color in hex value + * headLength - Number + * headWidth - Number + */ + + var lineGeometry; + var coneGeometry; + + function ArrowHelper( dir, origin, length, color, headLength, headWidth ) { + + // dir is assumed to be normalized + + Object3D.call( this ); + + if ( color === undefined ) color = 0xffff00; + if ( length === undefined ) length = 1; + if ( headLength === undefined ) headLength = 0.2 * length; + if ( headWidth === undefined ) headWidth = 0.2 * headLength; + + if ( lineGeometry === undefined ) { + + lineGeometry = new BufferGeometry(); + lineGeometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 1, 0 ], 3 ) ); + + coneGeometry = new CylinderBufferGeometry( 0, 0.5, 1, 5, 1 ); + coneGeometry.translate( 0, - 0.5, 0 ); + + } + + this.position.copy( origin ); + + this.line = new Line( lineGeometry, new LineBasicMaterial( { color: color } ) ); + this.line.matrixAutoUpdate = false; + this.add( this.line ); + + this.cone = new Mesh( coneGeometry, new MeshBasicMaterial( { color: color } ) ); + this.cone.matrixAutoUpdate = false; + this.add( this.cone ); + + this.setDirection( dir ); + this.setLength( length, headLength, headWidth ); + + } + + ArrowHelper.prototype = Object.create( Object3D.prototype ); + ArrowHelper.prototype.constructor = ArrowHelper; + + ArrowHelper.prototype.setDirection = ( function () { + + var axis = new Vector3(); + var radians; + + return function setDirection( dir ) { + + // dir is assumed to be normalized + + if ( dir.y > 0.99999 ) { + + this.quaternion.set( 0, 0, 0, 1 ); + + } else if ( dir.y < - 0.99999 ) { + + this.quaternion.set( 1, 0, 0, 0 ); + + } else { + + axis.set( dir.z, 0, - dir.x ).normalize(); + + radians = Math.acos( dir.y ); + + this.quaternion.setFromAxisAngle( axis, radians ); + + } + + }; + + }() ); + + ArrowHelper.prototype.setLength = function ( length, headLength, headWidth ) { + + if ( headLength === undefined ) headLength = 0.2 * length; + if ( headWidth === undefined ) headWidth = 0.2 * headLength; + + this.line.scale.set( 1, Math.max( 0, length - headLength ), 1 ); + this.line.updateMatrix(); + + this.cone.scale.set( headWidth, headLength, headWidth ); + this.cone.position.y = length; + this.cone.updateMatrix(); + + }; + + ArrowHelper.prototype.setColor = function ( color ) { + + this.line.material.color.copy( color ); + this.cone.material.color.copy( color ); + + }; + + /** + * @author sroucheray / http://sroucheray.org/ + * @author mrdoob / http://mrdoob.com/ + */ + + function AxesHelper( size ) { + + size = size || 1; + + var vertices = [ + 0, 0, 0, size, 0, 0, + 0, 0, 0, 0, size, 0, + 0, 0, 0, 0, 0, size + ]; + + var colors = [ + 1, 0, 0, 1, 0.6, 0, + 0, 1, 0, 0.6, 1, 0, + 0, 0, 1, 0, 0.6, 1 + ]; + + var geometry = new BufferGeometry(); + geometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) ); + geometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) ); + + var material = new LineBasicMaterial( { vertexColors: VertexColors } ); + + LineSegments.call( this, geometry, material ); + + } + + AxesHelper.prototype = Object.create( LineSegments.prototype ); + AxesHelper.prototype.constructor = AxesHelper; + + /** + * @author alteredq / http://alteredqualia.com/ + */ + + var SceneUtils = { + + createMultiMaterialObject: function ( geometry, materials ) { + + var group = new Group(); + + for ( var i = 0, l = materials.length; i < l; i ++ ) { + + group.add( new Mesh( geometry, materials[ i ] ) ); + + } + + return group; + + }, + + detach: function ( child, parent, scene ) { + + child.applyMatrix( parent.matrixWorld ); + parent.remove( child ); + scene.add( child ); + + }, + + attach: function ( child, scene, parent ) { + + child.applyMatrix( new Matrix4().getInverse( parent.matrixWorld ) ); + + scene.remove( child ); + parent.add( child ); + + } + + }; + + /** + * @author mrdoob / http://mrdoob.com/ + */ + + function Face4( a, b, c, d, normal, color, materialIndex ) { + + console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' ); + return new Face3( a, b, c, normal, color, materialIndex ); + + } + + var LineStrip = 0; + + var LinePieces = 1; + + function MeshFaceMaterial( materials ) { + + console.warn( 'THREE.MeshFaceMaterial has been removed. Use an Array instead.' ); + return materials; + + } + + function MultiMaterial( materials ) { + + if ( materials === undefined ) materials = []; + + console.warn( 'THREE.MultiMaterial has been removed. Use an Array instead.' ); + materials.isMultiMaterial = true; + materials.materials = materials; + materials.clone = function () { + + return materials.slice(); + + }; + return materials; + + } + + function PointCloud( geometry, material ) { + + console.warn( 'THREE.PointCloud has been renamed to THREE.Points.' ); + return new Points( geometry, material ); + + } + + function Particle( material ) { + + console.warn( 'THREE.Particle has been renamed to THREE.Sprite.' ); + return new Sprite( material ); + + } + + function ParticleSystem( geometry, material ) { + + console.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' ); + return new Points( geometry, material ); + + } + + function PointCloudMaterial( parameters ) { + + console.warn( 'THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.' ); + return new PointsMaterial( parameters ); + + } + + function ParticleBasicMaterial( parameters ) { + + console.warn( 'THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.' ); + return new PointsMaterial( parameters ); + + } + + function ParticleSystemMaterial( parameters ) { + + console.warn( 'THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.' ); + return new PointsMaterial( parameters ); + + } + + function Vertex( x, y, z ) { + + console.warn( 'THREE.Vertex has been removed. Use THREE.Vector3 instead.' ); + return new Vector3( x, y, z ); + + } + + // + + function DynamicBufferAttribute( array, itemSize ) { + + console.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' ); + return new BufferAttribute( array, itemSize ).setDynamic( true ); + + } + + function Int8Attribute( array, itemSize ) { + + console.warn( 'THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.' ); + return new Int8BufferAttribute( array, itemSize ); + + } + + function Uint8Attribute( array, itemSize ) { + + console.warn( 'THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.' ); + return new Uint8BufferAttribute( array, itemSize ); + + } + + function Uint8ClampedAttribute( array, itemSize ) { + + console.warn( 'THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.' ); + return new Uint8ClampedBufferAttribute( array, itemSize ); + + } + + function Int16Attribute( array, itemSize ) { + + console.warn( 'THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.' ); + return new Int16BufferAttribute( array, itemSize ); + + } + + function Uint16Attribute( array, itemSize ) { + + console.warn( 'THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.' ); + return new Uint16BufferAttribute( array, itemSize ); + + } + + function Int32Attribute( array, itemSize ) { + + console.warn( 'THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.' ); + return new Int32BufferAttribute( array, itemSize ); + + } + + function Uint32Attribute( array, itemSize ) { + + console.warn( 'THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.' ); + return new Uint32BufferAttribute( array, itemSize ); + + } + + function Float32Attribute( array, itemSize ) { + + console.warn( 'THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.' ); + return new Float32BufferAttribute( array, itemSize ); + + } + + function Float64Attribute( array, itemSize ) { + + console.warn( 'THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.' ); + return new Float64BufferAttribute( array, itemSize ); + + } + + // + + Curve.create = function ( construct, getPoint ) { + + console.log( 'THREE.Curve.create() has been deprecated' ); + + construct.prototype = Object.create( Curve.prototype ); + construct.prototype.constructor = construct; + construct.prototype.getPoint = getPoint; + + return construct; + + }; + + // + + Object.assign( CurvePath.prototype, { + + createPointsGeometry: function ( divisions ) { + + console.warn( 'THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' ); + + // generate geometry from path points (for Line or Points objects) + + var pts = this.getPoints( divisions ); + return this.createGeometry( pts ); + + }, + + createSpacedPointsGeometry: function ( divisions ) { + + console.warn( 'THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' ); + + // generate geometry from equidistant sampling along the path + + var pts = this.getSpacedPoints( divisions ); + return this.createGeometry( pts ); + + }, + + createGeometry: function ( points ) { + + console.warn( 'THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' ); + + var geometry = new Geometry(); + + for ( var i = 0, l = points.length; i < l; i ++ ) { + + var point = points[ i ]; + geometry.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) ); + + } + + return geometry; + + } + + } ); + + // + + Object.assign( Path.prototype, { + + fromPoints: function ( points ) { + + console.warn( 'THREE.Path: .fromPoints() has been renamed to .setFromPoints().' ); + this.setFromPoints( points ); + + } + + } ); + + // + + function ClosedSplineCurve3( points ) { + + console.warn( 'THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' ); + + CatmullRomCurve3.call( this, points ); + this.type = 'catmullrom'; + this.closed = true; + + } + + ClosedSplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype ); + + // + + function SplineCurve3( points ) { + + console.warn( 'THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' ); + + CatmullRomCurve3.call( this, points ); + this.type = 'catmullrom'; + + } + + SplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype ); + + // + + function Spline( points ) { + + console.warn( 'THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.' ); + + CatmullRomCurve3.call( this, points ); + this.type = 'catmullrom'; + + } + + Spline.prototype = Object.create( CatmullRomCurve3.prototype ); + + Object.assign( Spline.prototype, { + + initFromArray: function ( /* a */ ) { + + console.error( 'THREE.Spline: .initFromArray() has been removed.' ); + + }, + getControlPointsArray: function ( /* optionalTarget */ ) { + + console.error( 'THREE.Spline: .getControlPointsArray() has been removed.' ); + + }, + reparametrizeByArcLength: function ( /* samplingCoef */ ) { + + console.error( 'THREE.Spline: .reparametrizeByArcLength() has been removed.' ); + + } + + } ); + + // + + function AxisHelper( size ) { + + console.warn( 'THREE.AxisHelper has been renamed to THREE.AxesHelper.' ); + return new AxesHelper( size ); + + } + + function BoundingBoxHelper( object, color ) { + + console.warn( 'THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.' ); + return new BoxHelper( object, color ); + + } + + function EdgesHelper( object, hex ) { + + console.warn( 'THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.' ); + return new LineSegments( new EdgesGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) ); + + } + + GridHelper.prototype.setColors = function () { + + console.error( 'THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.' ); + + }; + + SkeletonHelper.prototype.update = function () { + + console.error( 'THREE.SkeletonHelper: update() no longer needs to be called.' ); + + }; + + function WireframeHelper( object, hex ) { + + console.warn( 'THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.' ); + return new LineSegments( new WireframeGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) ); + + } + + // + + Object.assign( Loader.prototype, { + + extractUrlBase: function ( url ) { + + console.warn( 'THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.' ); + return LoaderUtils.extractUrlBase( url ); + + } + + } ); + + function XHRLoader( manager ) { + + console.warn( 'THREE.XHRLoader has been renamed to THREE.FileLoader.' ); + return new FileLoader( manager ); + + } + + function BinaryTextureLoader( manager ) { + + console.warn( 'THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.' ); + return new DataTextureLoader( manager ); + + } + + // + + Object.assign( Box2.prototype, { + + center: function ( optionalTarget ) { + + console.warn( 'THREE.Box2: .center() has been renamed to .getCenter().' ); + return this.getCenter( optionalTarget ); + + }, + empty: function () { + + console.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' ); + return this.isEmpty(); + + }, + isIntersectionBox: function ( box ) { + + console.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' ); + return this.intersectsBox( box ); + + }, + size: function ( optionalTarget ) { + + console.warn( 'THREE.Box2: .size() has been renamed to .getSize().' ); + return this.getSize( optionalTarget ); + + } + } ); + + Object.assign( Box3.prototype, { + + center: function ( optionalTarget ) { + + console.warn( 'THREE.Box3: .center() has been renamed to .getCenter().' ); + return this.getCenter( optionalTarget ); + + }, + empty: function () { + + console.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' ); + return this.isEmpty(); + + }, + isIntersectionBox: function ( box ) { + + console.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' ); + return this.intersectsBox( box ); + + }, + isIntersectionSphere: function ( sphere ) { + + console.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' ); + return this.intersectsSphere( sphere ); + + }, + size: function ( optionalTarget ) { + + console.warn( 'THREE.Box3: .size() has been renamed to .getSize().' ); + return this.getSize( optionalTarget ); + + } + } ); + + Line3.prototype.center = function ( optionalTarget ) { + + console.warn( 'THREE.Line3: .center() has been renamed to .getCenter().' ); + return this.getCenter( optionalTarget ); + + }; + + Object.assign( _Math, { + + random16: function () { + + console.warn( 'THREE.Math: .random16() has been deprecated. Use Math.random() instead.' ); + return Math.random(); + + }, + + nearestPowerOfTwo: function ( value ) { + + console.warn( 'THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().' ); + return _Math.floorPowerOfTwo( value ); + + }, + + nextPowerOfTwo: function ( value ) { + + console.warn( 'THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().' ); + return _Math.ceilPowerOfTwo( value ); + + } + + } ); + + Object.assign( Matrix3.prototype, { + + flattenToArrayOffset: function ( array, offset ) { + + console.warn( "THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead." ); + return this.toArray( array, offset ); + + }, + multiplyVector3: function ( vector ) { + + console.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' ); + return vector.applyMatrix3( this ); + + }, + multiplyVector3Array: function ( /* a */ ) { + + console.error( 'THREE.Matrix3: .multiplyVector3Array() has been removed.' ); + + }, + applyToBuffer: function ( buffer /*, offset, length */ ) { + + console.warn( 'THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' ); + return this.applyToBufferAttribute( buffer ); + + }, + applyToVector3Array: function ( /* array, offset, length */ ) { + + console.error( 'THREE.Matrix3: .applyToVector3Array() has been removed.' ); + + } + + } ); + + Object.assign( Matrix4.prototype, { + + extractPosition: function ( m ) { + + console.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' ); + return this.copyPosition( m ); + + }, + flattenToArrayOffset: function ( array, offset ) { + + console.warn( "THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead." ); + return this.toArray( array, offset ); + + }, + getPosition: function () { + + var v1; + + return function getPosition() { + + if ( v1 === undefined ) v1 = new Vector3(); + console.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' ); + return v1.setFromMatrixColumn( this, 3 ); + + }; + + }(), + setRotationFromQuaternion: function ( q ) { + + console.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' ); + return this.makeRotationFromQuaternion( q ); + + }, + multiplyToArray: function () { + + console.warn( 'THREE.Matrix4: .multiplyToArray() has been removed.' ); + + }, + multiplyVector3: function ( vector ) { + + console.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.' ); + return vector.applyMatrix4( this ); + + }, + multiplyVector4: function ( vector ) { + + console.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' ); + return vector.applyMatrix4( this ); + + }, + multiplyVector3Array: function ( /* a */ ) { + + console.error( 'THREE.Matrix4: .multiplyVector3Array() has been removed.' ); + + }, + rotateAxis: function ( v ) { + + console.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' ); + v.transformDirection( this ); + + }, + crossVector: function ( vector ) { + + console.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' ); + return vector.applyMatrix4( this ); + + }, + translate: function () { + + console.error( 'THREE.Matrix4: .translate() has been removed.' ); + + }, + rotateX: function () { + + console.error( 'THREE.Matrix4: .rotateX() has been removed.' ); + + }, + rotateY: function () { + + console.error( 'THREE.Matrix4: .rotateY() has been removed.' ); + + }, + rotateZ: function () { + + console.error( 'THREE.Matrix4: .rotateZ() has been removed.' ); + + }, + rotateByAxis: function () { + + console.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' ); + + }, + applyToBuffer: function ( buffer /*, offset, length */ ) { + + console.warn( 'THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' ); + return this.applyToBufferAttribute( buffer ); + + }, + applyToVector3Array: function ( /* array, offset, length */ ) { + + console.error( 'THREE.Matrix4: .applyToVector3Array() has been removed.' ); + + }, + makeFrustum: function ( left, right, bottom, top, near, far ) { + + console.warn( 'THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.' ); + return this.makePerspective( left, right, top, bottom, near, far ); + + } + + } ); + + Plane.prototype.isIntersectionLine = function ( line ) { + + console.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' ); + return this.intersectsLine( line ); + + }; + + Quaternion.prototype.multiplyVector3 = function ( vector ) { + + console.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' ); + return vector.applyQuaternion( this ); + + }; + + Object.assign( Ray.prototype, { + + isIntersectionBox: function ( box ) { + + console.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' ); + return this.intersectsBox( box ); + + }, + isIntersectionPlane: function ( plane ) { + + console.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' ); + return this.intersectsPlane( plane ); + + }, + isIntersectionSphere: function ( sphere ) { + + console.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' ); + return this.intersectsSphere( sphere ); + + } + + } ); + + Object.assign( Shape.prototype, { + + extractAllPoints: function ( divisions ) { + + console.warn( 'THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.' ); + return this.extractPoints( divisions ); + + }, + extrude: function ( options ) { + + console.warn( 'THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.' ); + return new ExtrudeGeometry( this, options ); + + }, + makeGeometry: function ( options ) { + + console.warn( 'THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.' ); + return new ShapeGeometry( this, options ); + + } + + } ); + + Object.assign( Vector2.prototype, { + + fromAttribute: function ( attribute, index, offset ) { + + console.warn( 'THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().' ); + return this.fromBufferAttribute( attribute, index, offset ); + + }, + distanceToManhattan: function ( v ) { + + console.warn( 'THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' ); + return this.manhattanDistanceTo( v ); + + }, + lengthManhattan: function () { + + console.warn( 'THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().' ); + return this.manhattanLength(); + + } + + } ); + + Object.assign( Vector3.prototype, { + + setEulerFromRotationMatrix: function () { + + console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' ); + + }, + setEulerFromQuaternion: function () { + + console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' ); + + }, + getPositionFromMatrix: function ( m ) { + + console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' ); + return this.setFromMatrixPosition( m ); + + }, + getScaleFromMatrix: function ( m ) { + + console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' ); + return this.setFromMatrixScale( m ); + + }, + getColumnFromMatrix: function ( index, matrix ) { + + console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' ); + return this.setFromMatrixColumn( matrix, index ); + + }, + applyProjection: function ( m ) { + + console.warn( 'THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.' ); + return this.applyMatrix4( m ); + + }, + fromAttribute: function ( attribute, index, offset ) { + + console.warn( 'THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().' ); + return this.fromBufferAttribute( attribute, index, offset ); + + }, + distanceToManhattan: function ( v ) { + + console.warn( 'THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' ); + return this.manhattanDistanceTo( v ); + + }, + lengthManhattan: function () { + + console.warn( 'THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().' ); + return this.manhattanLength(); + + } + + } ); + + Object.assign( Vector4.prototype, { + + fromAttribute: function ( attribute, index, offset ) { + + console.warn( 'THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().' ); + return this.fromBufferAttribute( attribute, index, offset ); + + }, + lengthManhattan: function () { + + console.warn( 'THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().' ); + return this.manhattanLength(); + + } + + } ); + + // + + Geometry.prototype.computeTangents = function () { + + console.warn( 'THREE.Geometry: .computeTangents() has been removed.' ); + + }; + + Object.assign( Object3D.prototype, { + + getChildByName: function ( name ) { + + console.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' ); + return this.getObjectByName( name ); + + }, + renderDepth: function () { + + console.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' ); + + }, + translate: function ( distance, axis ) { + + console.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' ); + return this.translateOnAxis( axis, distance ); + + } + + } ); + + Object.defineProperties( Object3D.prototype, { + + eulerOrder: { + get: function () { + + console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' ); + return this.rotation.order; + + }, + set: function ( value ) { + + console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' ); + this.rotation.order = value; + + } + }, + useQuaternion: { + get: function () { + + console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' ); + + }, + set: function () { + + console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' ); + + } + } + + } ); + + Object.defineProperties( LOD.prototype, { + + objects: { + get: function () { + + console.warn( 'THREE.LOD: .objects has been renamed to .levels.' ); + return this.levels; + + } + } + + } ); + + Object.defineProperty( Skeleton.prototype, 'useVertexTexture', { + + get: function () { + + console.warn( 'THREE.Skeleton: useVertexTexture has been removed.' ); + + }, + set: function () { + + console.warn( 'THREE.Skeleton: useVertexTexture has been removed.' ); + + } + + } ); + + Object.defineProperty( Curve.prototype, '__arcLengthDivisions', { + + get: function () { + + console.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' ); + return this.arcLengthDivisions; + + }, + set: function ( value ) { + + console.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' ); + this.arcLengthDivisions = value; + + } + + } ); + + // + + PerspectiveCamera.prototype.setLens = function ( focalLength, filmGauge ) { + + console.warn( "THREE.PerspectiveCamera.setLens is deprecated. " + + "Use .setFocalLength and .filmGauge for a photographic setup." ); + + if ( filmGauge !== undefined ) this.filmGauge = filmGauge; + this.setFocalLength( focalLength ); + + }; + + // + + Object.defineProperties( Light.prototype, { + onlyShadow: { + set: function () { + + console.warn( 'THREE.Light: .onlyShadow has been removed.' ); + + } + }, + shadowCameraFov: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' ); + this.shadow.camera.fov = value; + + } + }, + shadowCameraLeft: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' ); + this.shadow.camera.left = value; + + } + }, + shadowCameraRight: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' ); + this.shadow.camera.right = value; + + } + }, + shadowCameraTop: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' ); + this.shadow.camera.top = value; + + } + }, + shadowCameraBottom: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' ); + this.shadow.camera.bottom = value; + + } + }, + shadowCameraNear: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' ); + this.shadow.camera.near = value; + + } + }, + shadowCameraFar: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' ); + this.shadow.camera.far = value; + + } + }, + shadowCameraVisible: { + set: function () { + + console.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' ); + + } + }, + shadowBias: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' ); + this.shadow.bias = value; + + } + }, + shadowDarkness: { + set: function () { + + console.warn( 'THREE.Light: .shadowDarkness has been removed.' ); + + } + }, + shadowMapWidth: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' ); + this.shadow.mapSize.width = value; + + } + }, + shadowMapHeight: { + set: function ( value ) { + + console.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' ); + this.shadow.mapSize.height = value; + + } + } + } ); + + // + + Object.defineProperties( BufferAttribute.prototype, { + + length: { + get: function () { + + console.warn( 'THREE.BufferAttribute: .length has been deprecated. Use .count instead.' ); + return this.array.length; + + } + } + + } ); + + Object.assign( BufferGeometry.prototype, { + + addIndex: function ( index ) { + + console.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' ); + this.setIndex( index ); + + }, + addDrawCall: function ( start, count, indexOffset ) { + + if ( indexOffset !== undefined ) { + + console.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' ); + + } + console.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' ); + this.addGroup( start, count ); + + }, + clearDrawCalls: function () { + + console.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' ); + this.clearGroups(); + + }, + computeTangents: function () { + + console.warn( 'THREE.BufferGeometry: .computeTangents() has been removed.' ); + + }, + computeOffsets: function () { + + console.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' ); + + } + + } ); + + Object.defineProperties( BufferGeometry.prototype, { + + drawcalls: { + get: function () { + + console.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' ); + return this.groups; + + } + }, + offsets: { + get: function () { + + console.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' ); + return this.groups; + + } + } + + } ); + + // + + Object.defineProperties( Uniform.prototype, { + + dynamic: { + set: function () { + + console.warn( 'THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.' ); + + } + }, + onUpdate: { + value: function () { + + console.warn( 'THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.' ); + return this; + + } + } + + } ); + + // + + Object.defineProperties( Material.prototype, { + + wrapAround: { + get: function () { + + console.warn( 'THREE.Material: .wrapAround has been removed.' ); + + }, + set: function () { + + console.warn( 'THREE.Material: .wrapAround has been removed.' ); + + } + }, + wrapRGB: { + get: function () { + + console.warn( 'THREE.Material: .wrapRGB has been removed.' ); + return new Color(); + + } + }, + + shading: { + get: function () { + + console.error( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' ); + + }, + set: function ( value ) { + + console.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' ); + this.flatShading = ( value === FlatShading ); + + } + } + + } ); + + Object.defineProperties( MeshPhongMaterial.prototype, { + + metal: { + get: function () { + + console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' ); + return false; + + }, + set: function () { + + console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' ); + + } + } + + } ); + + Object.defineProperties( ShaderMaterial.prototype, { + + derivatives: { + get: function () { + + console.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' ); + return this.extensions.derivatives; + + }, + set: function ( value ) { + + console.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' ); + this.extensions.derivatives = value; + + } + } + + } ); + + // + + Object.assign( WebGLRenderer.prototype, { + + getCurrentRenderTarget: function () { + + console.warn( 'THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().' ); + return this.getRenderTarget(); + + }, + + getMaxAnisotropy: function () { + + console.warn( 'THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().' ); + return this.capabilities.getMaxAnisotropy(); + + }, + + getPrecision: function () { + + console.warn( 'THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.' ); + return this.capabilities.precision; + + }, + + resetGLState: function () { + + console.warn( 'THREE.WebGLRenderer: .resetGLState() is now .state.reset().' ); + return this.state.reset(); + + }, + + supportsFloatTextures: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \'OES_texture_float\' ).' ); + return this.extensions.get( 'OES_texture_float' ); + + }, + supportsHalfFloatTextures: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \'OES_texture_half_float\' ).' ); + return this.extensions.get( 'OES_texture_half_float' ); + + }, + supportsStandardDerivatives: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \'OES_standard_derivatives\' ).' ); + return this.extensions.get( 'OES_standard_derivatives' ); + + }, + supportsCompressedTextureS3TC: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \'WEBGL_compressed_texture_s3tc\' ).' ); + return this.extensions.get( 'WEBGL_compressed_texture_s3tc' ); + + }, + supportsCompressedTexturePVRTC: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \'WEBGL_compressed_texture_pvrtc\' ).' ); + return this.extensions.get( 'WEBGL_compressed_texture_pvrtc' ); + + }, + supportsBlendMinMax: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \'EXT_blend_minmax\' ).' ); + return this.extensions.get( 'EXT_blend_minmax' ); + + }, + supportsVertexTextures: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.' ); + return this.capabilities.vertexTextures; + + }, + supportsInstancedArrays: function () { + + console.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \'ANGLE_instanced_arrays\' ).' ); + return this.extensions.get( 'ANGLE_instanced_arrays' ); + + }, + enableScissorTest: function ( boolean ) { + + console.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' ); + this.setScissorTest( boolean ); + + }, + initMaterial: function () { + + console.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' ); + + }, + addPrePlugin: function () { + + console.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' ); + + }, + addPostPlugin: function () { + + console.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' ); + + }, + updateShadowMap: function () { + + console.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' ); + + } + + } ); + + Object.defineProperties( WebGLRenderer.prototype, { + + shadowMapEnabled: { + get: function () { + + return this.shadowMap.enabled; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' ); + this.shadowMap.enabled = value; + + } + }, + shadowMapType: { + get: function () { + + return this.shadowMap.type; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' ); + this.shadowMap.type = value; + + } + }, + shadowMapCullFace: { + get: function () { + + return this.shadowMap.cullFace; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderer: .shadowMapCullFace is now .shadowMap.cullFace.' ); + this.shadowMap.cullFace = value; + + } + } + } ); + + Object.defineProperties( WebGLShadowMap.prototype, { + + cullFace: { + get: function () { + + return this.renderReverseSided ? CullFaceFront : CullFaceBack; + + }, + set: function ( cullFace ) { + + var value = ( cullFace !== CullFaceBack ); + console.warn( "WebGLRenderer: .shadowMap.cullFace is deprecated. Set .shadowMap.renderReverseSided to " + value + "." ); + this.renderReverseSided = value; + + } + } + + } ); + + // + + Object.defineProperties( WebGLRenderTarget.prototype, { + + wrapS: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' ); + return this.texture.wrapS; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' ); + this.texture.wrapS = value; + + } + }, + wrapT: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' ); + return this.texture.wrapT; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' ); + this.texture.wrapT = value; + + } + }, + magFilter: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' ); + return this.texture.magFilter; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' ); + this.texture.magFilter = value; + + } + }, + minFilter: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' ); + return this.texture.minFilter; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' ); + this.texture.minFilter = value; + + } + }, + anisotropy: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' ); + return this.texture.anisotropy; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' ); + this.texture.anisotropy = value; + + } + }, + offset: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' ); + return this.texture.offset; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' ); + this.texture.offset = value; + + } + }, + repeat: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' ); + return this.texture.repeat; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' ); + this.texture.repeat = value; + + } + }, + format: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' ); + return this.texture.format; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' ); + this.texture.format = value; + + } + }, + type: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' ); + return this.texture.type; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' ); + this.texture.type = value; + + } + }, + generateMipmaps: { + get: function () { + + console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' ); + return this.texture.generateMipmaps; + + }, + set: function ( value ) { + + console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' ); + this.texture.generateMipmaps = value; + + } + } + + } ); + + // + + Object.assign( WebVRManager.prototype, { + + getStandingMatrix: function () { + + console.warn( 'THREE.WebVRManager: .getStandingMatrix() has been removed.' ); + + } + + } ); + + Object.defineProperties( WebVRManager.prototype, { + + standing: { + set: function ( /* value */ ) { + + console.warn( 'THREE.WebVRManager: .standing has been removed.' ); + + } + } + + } ); + + // + + Audio.prototype.load = function ( file ) { + + console.warn( 'THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.' ); + var scope = this; + var audioLoader = new AudioLoader(); + audioLoader.load( file, function ( buffer ) { + + scope.setBuffer( buffer ); + + } ); + return this; + + }; + + AudioAnalyser.prototype.getData = function () { + + console.warn( 'THREE.AudioAnalyser: .getData() is now .getFrequencyData().' ); + return this.getFrequencyData(); + + }; + + // + + CubeCamera.prototype.updateCubeMap = function ( renderer, scene ) { + + console.warn( 'THREE.CubeCamera: .updateCubeMap() is now .update().' ); + return this.update( renderer, scene ); + + }; + + // + + var GeometryUtils = { + + merge: function ( geometry1, geometry2, materialIndexOffset ) { + + console.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' ); + var matrix; + + if ( geometry2.isMesh ) { + + geometry2.matrixAutoUpdate && geometry2.updateMatrix(); + + matrix = geometry2.matrix; + geometry2 = geometry2.geometry; + + } + + geometry1.merge( geometry2, matrix, materialIndexOffset ); + + }, + + center: function ( geometry ) { + + console.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' ); + return geometry.center(); + + } + + }; + + var ImageUtils = { + + crossOrigin: undefined, + + loadTexture: function ( url, mapping, onLoad, onError ) { + + console.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' ); + + var loader = new TextureLoader(); + loader.setCrossOrigin( this.crossOrigin ); + + var texture = loader.load( url, onLoad, undefined, onError ); + + if ( mapping ) texture.mapping = mapping; + + return texture; + + }, + + loadTextureCube: function ( urls, mapping, onLoad, onError ) { + + console.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' ); + + var loader = new CubeTextureLoader(); + loader.setCrossOrigin( this.crossOrigin ); + + var texture = loader.load( urls, onLoad, undefined, onError ); + + if ( mapping ) texture.mapping = mapping; + + return texture; + + }, + + loadCompressedTexture: function () { + + console.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' ); + + }, + + loadCompressedTextureCube: function () { + + console.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' ); + + } + + }; + + // + + function Projector() { + + console.error( 'THREE.Projector has been moved to /examples/js/renderers/Projector.js.' ); + + this.projectVector = function ( vector, camera ) { + + console.warn( 'THREE.Projector: .projectVector() is now vector.project().' ); + vector.project( camera ); + + }; + + this.unprojectVector = function ( vector, camera ) { + + console.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' ); + vector.unproject( camera ); + + }; + + this.pickingRay = function () { + + console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' ); + + }; + + } + + // + + function CanvasRenderer() { + + console.error( 'THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js' ); + + this.domElement = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ); + this.clear = function () {}; + this.render = function () {}; + this.setClearColor = function () {}; + this.setSize = function () {}; + + } + + exports.WebGLRenderTargetCube = WebGLRenderTargetCube; + exports.WebGLRenderTarget = WebGLRenderTarget; + exports.WebGLRenderer = WebGLRenderer; + exports.ShaderLib = ShaderLib; + exports.UniformsLib = UniformsLib; + exports.UniformsUtils = UniformsUtils; + exports.ShaderChunk = ShaderChunk; + exports.FogExp2 = FogExp2; + exports.Fog = Fog; + exports.Scene = Scene; + exports.LensFlare = LensFlare; + exports.Sprite = Sprite; + exports.LOD = LOD; + exports.SkinnedMesh = SkinnedMesh; + exports.Skeleton = Skeleton; + exports.Bone = Bone; + exports.Mesh = Mesh; + exports.LineSegments = LineSegments; + exports.LineLoop = LineLoop; + exports.Line = Line; + exports.Points = Points; + exports.Group = Group; + exports.VideoTexture = VideoTexture; + exports.DataTexture = DataTexture; + exports.CompressedTexture = CompressedTexture; + exports.CubeTexture = CubeTexture; + exports.CanvasTexture = CanvasTexture; + exports.DepthTexture = DepthTexture; + exports.Texture = Texture; + exports.CompressedTextureLoader = CompressedTextureLoader; + exports.DataTextureLoader = DataTextureLoader; + exports.CubeTextureLoader = CubeTextureLoader; + exports.TextureLoader = TextureLoader; + exports.ObjectLoader = ObjectLoader; + exports.MaterialLoader = MaterialLoader; + exports.BufferGeometryLoader = BufferGeometryLoader; + exports.DefaultLoadingManager = DefaultLoadingManager; + exports.LoadingManager = LoadingManager; + exports.JSONLoader = JSONLoader; + exports.ImageLoader = ImageLoader; + exports.ImageBitmapLoader = ImageBitmapLoader; + exports.FontLoader = FontLoader; + exports.FileLoader = FileLoader; + exports.Loader = Loader; + exports.LoaderUtils = LoaderUtils; + exports.Cache = Cache; + exports.AudioLoader = AudioLoader; + exports.SpotLightShadow = SpotLightShadow; + exports.SpotLight = SpotLight; + exports.PointLight = PointLight; + exports.RectAreaLight = RectAreaLight; + exports.HemisphereLight = HemisphereLight; + exports.DirectionalLightShadow = DirectionalLightShadow; + exports.DirectionalLight = DirectionalLight; + exports.AmbientLight = AmbientLight; + exports.LightShadow = LightShadow; + exports.Light = Light; + exports.StereoCamera = StereoCamera; + exports.PerspectiveCamera = PerspectiveCamera; + exports.OrthographicCamera = OrthographicCamera; + exports.CubeCamera = CubeCamera; + exports.ArrayCamera = ArrayCamera; + exports.Camera = Camera; + exports.AudioListener = AudioListener; + exports.PositionalAudio = PositionalAudio; + exports.AudioContext = AudioContext; + exports.AudioAnalyser = AudioAnalyser; + exports.Audio = Audio; + exports.VectorKeyframeTrack = VectorKeyframeTrack; + exports.StringKeyframeTrack = StringKeyframeTrack; + exports.QuaternionKeyframeTrack = QuaternionKeyframeTrack; + exports.NumberKeyframeTrack = NumberKeyframeTrack; + exports.ColorKeyframeTrack = ColorKeyframeTrack; + exports.BooleanKeyframeTrack = BooleanKeyframeTrack; + exports.PropertyMixer = PropertyMixer; + exports.PropertyBinding = PropertyBinding; + exports.KeyframeTrack = KeyframeTrack; + exports.AnimationUtils = AnimationUtils; + exports.AnimationObjectGroup = AnimationObjectGroup; + exports.AnimationMixer = AnimationMixer; + exports.AnimationClip = AnimationClip; + exports.Uniform = Uniform; + exports.InstancedBufferGeometry = InstancedBufferGeometry; + exports.BufferGeometry = BufferGeometry; + exports.Geometry = Geometry; + exports.InterleavedBufferAttribute = InterleavedBufferAttribute; + exports.InstancedInterleavedBuffer = InstancedInterleavedBuffer; + exports.InterleavedBuffer = InterleavedBuffer; + exports.InstancedBufferAttribute = InstancedBufferAttribute; + exports.Face3 = Face3; + exports.Object3D = Object3D; + exports.Raycaster = Raycaster; + exports.Layers = Layers; + exports.EventDispatcher = EventDispatcher; + exports.Clock = Clock; + exports.QuaternionLinearInterpolant = QuaternionLinearInterpolant; + exports.LinearInterpolant = LinearInterpolant; + exports.DiscreteInterpolant = DiscreteInterpolant; + exports.CubicInterpolant = CubicInterpolant; + exports.Interpolant = Interpolant; + exports.Triangle = Triangle; + exports.Math = _Math; + exports.Spherical = Spherical; + exports.Cylindrical = Cylindrical; + exports.Plane = Plane; + exports.Frustum = Frustum; + exports.Sphere = Sphere; + exports.Ray = Ray; + exports.Matrix4 = Matrix4; + exports.Matrix3 = Matrix3; + exports.Box3 = Box3; + exports.Box2 = Box2; + exports.Line3 = Line3; + exports.Euler = Euler; + exports.Vector4 = Vector4; + exports.Vector3 = Vector3; + exports.Vector2 = Vector2; + exports.Quaternion = Quaternion; + exports.Color = Color; + exports.ImmediateRenderObject = ImmediateRenderObject; + exports.VertexNormalsHelper = VertexNormalsHelper; + exports.SpotLightHelper = SpotLightHelper; + exports.SkeletonHelper = SkeletonHelper; + exports.PointLightHelper = PointLightHelper; + exports.RectAreaLightHelper = RectAreaLightHelper; + exports.HemisphereLightHelper = HemisphereLightHelper; + exports.GridHelper = GridHelper; + exports.PolarGridHelper = PolarGridHelper; + exports.FaceNormalsHelper = FaceNormalsHelper; + exports.DirectionalLightHelper = DirectionalLightHelper; + exports.CameraHelper = CameraHelper; + exports.BoxHelper = BoxHelper; + exports.Box3Helper = Box3Helper; + exports.PlaneHelper = PlaneHelper; + exports.ArrowHelper = ArrowHelper; + exports.AxesHelper = AxesHelper; + exports.Shape = Shape; + exports.Path = Path; + exports.ShapePath = ShapePath; + exports.Font = Font; + exports.CurvePath = CurvePath; + exports.Curve = Curve; + exports.ShapeUtils = ShapeUtils; + exports.SceneUtils = SceneUtils; + exports.WebGLUtils = WebGLUtils; + exports.WireframeGeometry = WireframeGeometry; + exports.ParametricGeometry = ParametricGeometry; + exports.ParametricBufferGeometry = ParametricBufferGeometry; + exports.TetrahedronGeometry = TetrahedronGeometry; + exports.TetrahedronBufferGeometry = TetrahedronBufferGeometry; + exports.OctahedronGeometry = OctahedronGeometry; + exports.OctahedronBufferGeometry = OctahedronBufferGeometry; + exports.IcosahedronGeometry = IcosahedronGeometry; + exports.IcosahedronBufferGeometry = IcosahedronBufferGeometry; + exports.DodecahedronGeometry = DodecahedronGeometry; + exports.DodecahedronBufferGeometry = DodecahedronBufferGeometry; + exports.PolyhedronGeometry = PolyhedronGeometry; + exports.PolyhedronBufferGeometry = PolyhedronBufferGeometry; + exports.TubeGeometry = TubeGeometry; + exports.TubeBufferGeometry = TubeBufferGeometry; + exports.TorusKnotGeometry = TorusKnotGeometry; + exports.TorusKnotBufferGeometry = TorusKnotBufferGeometry; + exports.TorusGeometry = TorusGeometry; + exports.TorusBufferGeometry = TorusBufferGeometry; + exports.TextGeometry = TextGeometry; + exports.TextBufferGeometry = TextBufferGeometry; + exports.SphereGeometry = SphereGeometry; + exports.SphereBufferGeometry = SphereBufferGeometry; + exports.RingGeometry = RingGeometry; + exports.RingBufferGeometry = RingBufferGeometry; + exports.PlaneGeometry = PlaneGeometry; + exports.PlaneBufferGeometry = PlaneBufferGeometry; + exports.LatheGeometry = LatheGeometry; + exports.LatheBufferGeometry = LatheBufferGeometry; + exports.ShapeGeometry = ShapeGeometry; + exports.ShapeBufferGeometry = ShapeBufferGeometry; + exports.ExtrudeGeometry = ExtrudeGeometry; + exports.ExtrudeBufferGeometry = ExtrudeBufferGeometry; + exports.EdgesGeometry = EdgesGeometry; + exports.ConeGeometry = ConeGeometry; + exports.ConeBufferGeometry = ConeBufferGeometry; + exports.CylinderGeometry = CylinderGeometry; + exports.CylinderBufferGeometry = CylinderBufferGeometry; + exports.CircleGeometry = CircleGeometry; + exports.CircleBufferGeometry = CircleBufferGeometry; + exports.BoxGeometry = BoxGeometry; + exports.BoxBufferGeometry = BoxBufferGeometry; + exports.ShadowMaterial = ShadowMaterial; + exports.SpriteMaterial = SpriteMaterial; + exports.RawShaderMaterial = RawShaderMaterial; + exports.ShaderMaterial = ShaderMaterial; + exports.PointsMaterial = PointsMaterial; + exports.MeshPhysicalMaterial = MeshPhysicalMaterial; + exports.MeshStandardMaterial = MeshStandardMaterial; + exports.MeshPhongMaterial = MeshPhongMaterial; + exports.MeshToonMaterial = MeshToonMaterial; + exports.MeshNormalMaterial = MeshNormalMaterial; + exports.MeshLambertMaterial = MeshLambertMaterial; + exports.MeshDepthMaterial = MeshDepthMaterial; + exports.MeshDistanceMaterial = MeshDistanceMaterial; + exports.MeshBasicMaterial = MeshBasicMaterial; + exports.LineDashedMaterial = LineDashedMaterial; + exports.LineBasicMaterial = LineBasicMaterial; + exports.Material = Material; + exports.Float64BufferAttribute = Float64BufferAttribute; + exports.Float32BufferAttribute = Float32BufferAttribute; + exports.Uint32BufferAttribute = Uint32BufferAttribute; + exports.Int32BufferAttribute = Int32BufferAttribute; + exports.Uint16BufferAttribute = Uint16BufferAttribute; + exports.Int16BufferAttribute = Int16BufferAttribute; + exports.Uint8ClampedBufferAttribute = Uint8ClampedBufferAttribute; + exports.Uint8BufferAttribute = Uint8BufferAttribute; + exports.Int8BufferAttribute = Int8BufferAttribute; + exports.BufferAttribute = BufferAttribute; + exports.ArcCurve = ArcCurve; + exports.CatmullRomCurve3 = CatmullRomCurve3; + exports.CubicBezierCurve = CubicBezierCurve; + exports.CubicBezierCurve3 = CubicBezierCurve3; + exports.EllipseCurve = EllipseCurve; + exports.LineCurve = LineCurve; + exports.LineCurve3 = LineCurve3; + exports.QuadraticBezierCurve = QuadraticBezierCurve; + exports.QuadraticBezierCurve3 = QuadraticBezierCurve3; + exports.SplineCurve = SplineCurve; + exports.REVISION = REVISION; + exports.MOUSE = MOUSE; + exports.CullFaceNone = CullFaceNone; + exports.CullFaceBack = CullFaceBack; + exports.CullFaceFront = CullFaceFront; + exports.CullFaceFrontBack = CullFaceFrontBack; + exports.FrontFaceDirectionCW = FrontFaceDirectionCW; + exports.FrontFaceDirectionCCW = FrontFaceDirectionCCW; + exports.BasicShadowMap = BasicShadowMap; + exports.PCFShadowMap = PCFShadowMap; + exports.PCFSoftShadowMap = PCFSoftShadowMap; + exports.FrontSide = FrontSide; + exports.BackSide = BackSide; + exports.DoubleSide = DoubleSide; + exports.FlatShading = FlatShading; + exports.SmoothShading = SmoothShading; + exports.NoColors = NoColors; + exports.FaceColors = FaceColors; + exports.VertexColors = VertexColors; + exports.NoBlending = NoBlending; + exports.NormalBlending = NormalBlending; + exports.AdditiveBlending = AdditiveBlending; + exports.SubtractiveBlending = SubtractiveBlending; + exports.MultiplyBlending = MultiplyBlending; + exports.CustomBlending = CustomBlending; + exports.AddEquation = AddEquation; + exports.SubtractEquation = SubtractEquation; + exports.ReverseSubtractEquation = ReverseSubtractEquation; + exports.MinEquation = MinEquation; + exports.MaxEquation = MaxEquation; + exports.ZeroFactor = ZeroFactor; + exports.OneFactor = OneFactor; + exports.SrcColorFactor = SrcColorFactor; + exports.OneMinusSrcColorFactor = OneMinusSrcColorFactor; + exports.SrcAlphaFactor = SrcAlphaFactor; + exports.OneMinusSrcAlphaFactor = OneMinusSrcAlphaFactor; + exports.DstAlphaFactor = DstAlphaFactor; + exports.OneMinusDstAlphaFactor = OneMinusDstAlphaFactor; + exports.DstColorFactor = DstColorFactor; + exports.OneMinusDstColorFactor = OneMinusDstColorFactor; + exports.SrcAlphaSaturateFactor = SrcAlphaSaturateFactor; + exports.NeverDepth = NeverDepth; + exports.AlwaysDepth = AlwaysDepth; + exports.LessDepth = LessDepth; + exports.LessEqualDepth = LessEqualDepth; + exports.EqualDepth = EqualDepth; + exports.GreaterEqualDepth = GreaterEqualDepth; + exports.GreaterDepth = GreaterDepth; + exports.NotEqualDepth = NotEqualDepth; + exports.MultiplyOperation = MultiplyOperation; + exports.MixOperation = MixOperation; + exports.AddOperation = AddOperation; + exports.NoToneMapping = NoToneMapping; + exports.LinearToneMapping = LinearToneMapping; + exports.ReinhardToneMapping = ReinhardToneMapping; + exports.Uncharted2ToneMapping = Uncharted2ToneMapping; + exports.CineonToneMapping = CineonToneMapping; + exports.UVMapping = UVMapping; + exports.CubeReflectionMapping = CubeReflectionMapping; + exports.CubeRefractionMapping = CubeRefractionMapping; + exports.EquirectangularReflectionMapping = EquirectangularReflectionMapping; + exports.EquirectangularRefractionMapping = EquirectangularRefractionMapping; + exports.SphericalReflectionMapping = SphericalReflectionMapping; + exports.CubeUVReflectionMapping = CubeUVReflectionMapping; + exports.CubeUVRefractionMapping = CubeUVRefractionMapping; + exports.RepeatWrapping = RepeatWrapping; + exports.ClampToEdgeWrapping = ClampToEdgeWrapping; + exports.MirroredRepeatWrapping = MirroredRepeatWrapping; + exports.NearestFilter = NearestFilter; + exports.NearestMipMapNearestFilter = NearestMipMapNearestFilter; + exports.NearestMipMapLinearFilter = NearestMipMapLinearFilter; + exports.LinearFilter = LinearFilter; + exports.LinearMipMapNearestFilter = LinearMipMapNearestFilter; + exports.LinearMipMapLinearFilter = LinearMipMapLinearFilter; + exports.UnsignedByteType = UnsignedByteType; + exports.ByteType = ByteType; + exports.ShortType = ShortType; + exports.UnsignedShortType = UnsignedShortType; + exports.IntType = IntType; + exports.UnsignedIntType = UnsignedIntType; + exports.FloatType = FloatType; + exports.HalfFloatType = HalfFloatType; + exports.UnsignedShort4444Type = UnsignedShort4444Type; + exports.UnsignedShort5551Type = UnsignedShort5551Type; + exports.UnsignedShort565Type = UnsignedShort565Type; + exports.UnsignedInt248Type = UnsignedInt248Type; + exports.AlphaFormat = AlphaFormat; + exports.RGBFormat = RGBFormat; + exports.RGBAFormat = RGBAFormat; + exports.LuminanceFormat = LuminanceFormat; + exports.LuminanceAlphaFormat = LuminanceAlphaFormat; + exports.RGBEFormat = RGBEFormat; + exports.DepthFormat = DepthFormat; + exports.DepthStencilFormat = DepthStencilFormat; + exports.RGB_S3TC_DXT1_Format = RGB_S3TC_DXT1_Format; + exports.RGBA_S3TC_DXT1_Format = RGBA_S3TC_DXT1_Format; + exports.RGBA_S3TC_DXT3_Format = RGBA_S3TC_DXT3_Format; + exports.RGBA_S3TC_DXT5_Format = RGBA_S3TC_DXT5_Format; + exports.RGB_PVRTC_4BPPV1_Format = RGB_PVRTC_4BPPV1_Format; + exports.RGB_PVRTC_2BPPV1_Format = RGB_PVRTC_2BPPV1_Format; + exports.RGBA_PVRTC_4BPPV1_Format = RGBA_PVRTC_4BPPV1_Format; + exports.RGBA_PVRTC_2BPPV1_Format = RGBA_PVRTC_2BPPV1_Format; + exports.RGB_ETC1_Format = RGB_ETC1_Format; + exports.LoopOnce = LoopOnce; + exports.LoopRepeat = LoopRepeat; + exports.LoopPingPong = LoopPingPong; + exports.InterpolateDiscrete = InterpolateDiscrete; + exports.InterpolateLinear = InterpolateLinear; + exports.InterpolateSmooth = InterpolateSmooth; + exports.ZeroCurvatureEnding = ZeroCurvatureEnding; + exports.ZeroSlopeEnding = ZeroSlopeEnding; + exports.WrapAroundEnding = WrapAroundEnding; + exports.TrianglesDrawMode = TrianglesDrawMode; + exports.TriangleStripDrawMode = TriangleStripDrawMode; + exports.TriangleFanDrawMode = TriangleFanDrawMode; + exports.LinearEncoding = LinearEncoding; + exports.sRGBEncoding = sRGBEncoding; + exports.GammaEncoding = GammaEncoding; + exports.RGBEEncoding = RGBEEncoding; + exports.LogLuvEncoding = LogLuvEncoding; + exports.RGBM7Encoding = RGBM7Encoding; + exports.RGBM16Encoding = RGBM16Encoding; + exports.RGBDEncoding = RGBDEncoding; + exports.BasicDepthPacking = BasicDepthPacking; + exports.RGBADepthPacking = RGBADepthPacking; + exports.CubeGeometry = BoxGeometry; + exports.Face4 = Face4; + exports.LineStrip = LineStrip; + exports.LinePieces = LinePieces; + exports.MeshFaceMaterial = MeshFaceMaterial; + exports.MultiMaterial = MultiMaterial; + exports.PointCloud = PointCloud; + exports.Particle = Particle; + exports.ParticleSystem = ParticleSystem; + exports.PointCloudMaterial = PointCloudMaterial; + exports.ParticleBasicMaterial = ParticleBasicMaterial; + exports.ParticleSystemMaterial = ParticleSystemMaterial; + exports.Vertex = Vertex; + exports.DynamicBufferAttribute = DynamicBufferAttribute; + exports.Int8Attribute = Int8Attribute; + exports.Uint8Attribute = Uint8Attribute; + exports.Uint8ClampedAttribute = Uint8ClampedAttribute; + exports.Int16Attribute = Int16Attribute; + exports.Uint16Attribute = Uint16Attribute; + exports.Int32Attribute = Int32Attribute; + exports.Uint32Attribute = Uint32Attribute; + exports.Float32Attribute = Float32Attribute; + exports.Float64Attribute = Float64Attribute; + exports.ClosedSplineCurve3 = ClosedSplineCurve3; + exports.SplineCurve3 = SplineCurve3; + exports.Spline = Spline; + exports.AxisHelper = AxisHelper; + exports.BoundingBoxHelper = BoundingBoxHelper; + exports.EdgesHelper = EdgesHelper; + exports.WireframeHelper = WireframeHelper; + exports.XHRLoader = XHRLoader; + exports.BinaryTextureLoader = BinaryTextureLoader; + exports.GeometryUtils = GeometryUtils; + exports.ImageUtils = ImageUtils; + exports.Projector = Projector; + exports.CanvasRenderer = CanvasRenderer; + + Object.defineProperty(exports, '__esModule', { value: true }); + +}))); diff --git a/seminar06-planning/simulator/webpack.config.js b/seminar06-planning/simulator/webpack.config.js new file mode 100644 index 0000000..63d2be8 --- /dev/null +++ b/seminar06-planning/simulator/webpack.config.js @@ -0,0 +1,22 @@ +const path = require('path'); +const webpack = require('webpack'); +const WrapperPlugin = require('wrapper-webpack-plugin'); + +module.exports = { + entry: { + PathPlannerWorker: './workers/PathPlannerWorker.js', + Dash: './js/Dash.js' + }, + devtool: 'eval-source-map', + plugins: [ + new WrapperPlugin({ + test: /PathPlannerWorker.js/, + header: 'function dash_initPathPlannerWorker() {', + footer: '} if (typeof(window) === undefined) dash_initPathPlannerWorker();' + }) + ], + output: { + path: path.resolve(__dirname, 'dist'), + filename: '[name].js' + } +}; diff --git a/seminar06-planning/simulator/workers/.gitignore b/seminar06-planning/simulator/workers/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/seminar06-planning/simulator/workers/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/seminar06-planning/simulator/workers/PathPlannerWorker.js b/seminar06-planning/simulator/workers/PathPlannerWorker.js new file mode 100644 index 0000000..f42b607 --- /dev/null +++ b/seminar06-planning/simulator/workers/PathPlannerWorker.js @@ -0,0 +1,86 @@ +import THREE from "script-loader!../vendor/three.js"; +import Utils from "script-loader!../js/Utils.js"; +import PathPlanner from "../js/autonomy/path-planning/PathPlanner.js"; +import ExternalPathPlanner from "../js/autonomy/path-planning/ExternalPlanner.js"; +import LanePath from "../js/autonomy/LanePath.js"; +import StaticObstacle from "../js/autonomy/StaticObstacle.js"; +import DynamicObstacle from "../js/autonomy/DynamicObstacle.js"; + +function init() { + let pathPlanner; + try { + // pathPlanner = new PathPlanner(); + pathPlanner = new ExternalPathPlanner() + } catch (e) { + console.log('Error initializing path planner:'); + console.log(e); + self.postMessage({ error: "initialization_failed" }); + return; + } + + self.onmessage = function(event) { + if (event.data.type === 'notify_case_status') { + pathPlanner.notify_scenario_status(event.data.status); + return; + } + if (event.data.type != 'plan') { + console.log("unkonwn posted message type: " + event); + return; + } + + const { config, vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles, reset } = event.data; + + LanePath.hydrate(lanePath); + staticObstacles.forEach(o => StaticObstacle.hydrate(o)); + dynamicObstacles.forEach(o => DynamicObstacle.hydrate(o)); + + if (reset) pathPlanner.reset(); + + pathPlanner.config = config; + + let should_retry = true; + while (should_retry) { + let planner_result; + try { + planner_result = pathPlanner.plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles); + should_retry = planner_result.planner_state == "unavailable"; + } catch (error) { + if (error.name != "TimeoutError" && error.name != "NetworkError") { + console.log('Planning request error: '); + console.log(error); + self.postMessage({ error: error.toString() }); + should_retry = false; + break; + } + } + + if (should_retry) { + self.postMessage({ error: "planner_unavailable" }); + } else { + const { + path, + fromVehicleSegment, + fromVehicleParams, + latticeStartStation, + dynamicObstacleGrid + } = planner_result; + + self.postMessage({ + path, + fromVehicleSegment, + fromVehicleParams, + vehiclePose, + vehicleStation, + latticeStartStation, + config, + dynamicObstacleGrid }); + } + } + }; +} + +if (typeof(window) === 'undefined') { + init(); +} else { + window.dash_initPathPlannerWorker = init; +}