(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports", "three"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("three"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.three);
    global.RollerCoaster = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.TreesGeometry = _exports.SkyGeometry = _exports.RollerCoasterShadowGeometry = _exports.RollerCoasterLiftersGeometry = _exports.RollerCoasterGeometry = void 0;

  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

  var RollerCoasterGeometry = /*#__PURE__*/function (_BufferGeometry) {
    _inherits(RollerCoasterGeometry, _BufferGeometry);

    var _super = _createSuper(RollerCoasterGeometry);

    function RollerCoasterGeometry(curve, divisions) {
      var _this;

      _classCallCheck(this, RollerCoasterGeometry);

      _this = _super.call(this);
      var vertices = [];
      var normals = [];
      var colors = [];
      var color1 = [1, 1, 1];
      var color2 = [1, 1, 0];
      var up = new _three.Vector3(0, 1, 0);
      var forward = new _three.Vector3();
      var right = new _three.Vector3();
      var quaternion = new _three.Quaternion();
      var prevQuaternion = new _three.Quaternion();
      prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
      var point = new _three.Vector3();
      var prevPoint = new _three.Vector3();
      prevPoint.copy(curve.getPointAt(0)); // shapes

      var step = [new _three.Vector3(-0.225, 0, 0), new _three.Vector3(0, -0.050, 0), new _three.Vector3(0, -0.175, 0), new _three.Vector3(0, -0.050, 0), new _three.Vector3(0.225, 0, 0), new _three.Vector3(0, -0.175, 0)];
      var PI2 = Math.PI * 2;
      var sides = 5;
      var tube1 = [];

      for (var i = 0; i < sides; i++) {
        var angle = i / sides * PI2;
        tube1.push(new _three.Vector3(Math.sin(angle) * 0.06, Math.cos(angle) * 0.06, 0));
      }

      sides = 6;
      var tube2 = [];

      for (var _i = 0; _i < sides; _i++) {
        var _angle = _i / sides * PI2;

        tube2.push(new _three.Vector3(Math.sin(_angle) * 0.025, Math.cos(_angle) * 0.025, 0));
      }

      var vector = new _three.Vector3();
      var normal = new _three.Vector3();

      function drawShape(shape, color) {
        normal.set(0, 0, -1).applyQuaternion(quaternion);

        for (var j = 0; j < shape.length; j++) {
          vector.copy(shape[j]);
          vector.applyQuaternion(quaternion);
          vector.add(point);
          vertices.push(vector.x, vector.y, vector.z);
          normals.push(normal.x, normal.y, normal.z);
          colors.push(color[0], color[1], color[2]);
        }

        normal.set(0, 0, 1).applyQuaternion(quaternion);

        for (var _j = shape.length - 1; _j >= 0; _j--) {
          vector.copy(shape[_j]);
          vector.applyQuaternion(quaternion);
          vector.add(point);
          vertices.push(vector.x, vector.y, vector.z);
          normals.push(normal.x, normal.y, normal.z);
          colors.push(color[0], color[1], color[2]);
        }
      }

      var vector1 = new _three.Vector3();
      var vector2 = new _three.Vector3();
      var vector3 = new _three.Vector3();
      var vector4 = new _three.Vector3();
      var normal1 = new _three.Vector3();
      var normal2 = new _three.Vector3();
      var normal3 = new _three.Vector3();
      var normal4 = new _three.Vector3();

      function extrudeShape(shape, offset, color) {
        for (var j = 0, jl = shape.length; j < jl; j++) {
          var point1 = shape[j];
          var point2 = shape[(j + 1) % jl];
          vector1.copy(point1).add(offset);
          vector1.applyQuaternion(quaternion);
          vector1.add(point);
          vector2.copy(point2).add(offset);
          vector2.applyQuaternion(quaternion);
          vector2.add(point);
          vector3.copy(point2).add(offset);
          vector3.applyQuaternion(prevQuaternion);
          vector3.add(prevPoint);
          vector4.copy(point1).add(offset);
          vector4.applyQuaternion(prevQuaternion);
          vector4.add(prevPoint);
          vertices.push(vector1.x, vector1.y, vector1.z);
          vertices.push(vector2.x, vector2.y, vector2.z);
          vertices.push(vector4.x, vector4.y, vector4.z);
          vertices.push(vector2.x, vector2.y, vector2.z);
          vertices.push(vector3.x, vector3.y, vector3.z);
          vertices.push(vector4.x, vector4.y, vector4.z); //

          normal1.copy(point1);
          normal1.applyQuaternion(quaternion);
          normal1.normalize();
          normal2.copy(point2);
          normal2.applyQuaternion(quaternion);
          normal2.normalize();
          normal3.copy(point2);
          normal3.applyQuaternion(prevQuaternion);
          normal3.normalize();
          normal4.copy(point1);
          normal4.applyQuaternion(prevQuaternion);
          normal4.normalize();
          normals.push(normal1.x, normal1.y, normal1.z);
          normals.push(normal2.x, normal2.y, normal2.z);
          normals.push(normal4.x, normal4.y, normal4.z);
          normals.push(normal2.x, normal2.y, normal2.z);
          normals.push(normal3.x, normal3.y, normal3.z);
          normals.push(normal4.x, normal4.y, normal4.z);
          colors.push(color[0], color[1], color[2]);
          colors.push(color[0], color[1], color[2]);
          colors.push(color[0], color[1], color[2]);
          colors.push(color[0], color[1], color[2]);
          colors.push(color[0], color[1], color[2]);
          colors.push(color[0], color[1], color[2]);
        }
      }

      var offset = new _three.Vector3();

      for (var _i2 = 1; _i2 <= divisions; _i2++) {
        point.copy(curve.getPointAt(_i2 / divisions));
        up.set(0, 1, 0);
        forward.subVectors(point, prevPoint).normalize();
        right.crossVectors(up, forward).normalize();
        up.crossVectors(forward, right);

        var _angle2 = Math.atan2(forward.x, forward.z);

        quaternion.setFromAxisAngle(up, _angle2);

        if (_i2 % 2 === 0) {
          drawShape(step, color2);
        }

        extrudeShape(tube1, offset.set(0, -0.125, 0), color2);
        extrudeShape(tube2, offset.set(0.2, 0, 0), color1);
        extrudeShape(tube2, offset.set(-0.2, 0, 0), color1);
        prevPoint.copy(point);
        prevQuaternion.copy(quaternion);
      } // console.log( vertices.length );


      _this.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));

      _this.setAttribute('normal', new _three.BufferAttribute(new Float32Array(normals), 3));

      _this.setAttribute('color', new _three.BufferAttribute(new Float32Array(colors), 3));

      return _this;
    }

    return _createClass(RollerCoasterGeometry);
  }(_three.BufferGeometry);

  _exports.RollerCoasterGeometry = RollerCoasterGeometry;

  var RollerCoasterLiftersGeometry = /*#__PURE__*/function (_BufferGeometry2) {
    _inherits(RollerCoasterLiftersGeometry, _BufferGeometry2);

    var _super2 = _createSuper(RollerCoasterLiftersGeometry);

    function RollerCoasterLiftersGeometry(curve, divisions) {
      var _this2;

      _classCallCheck(this, RollerCoasterLiftersGeometry);

      _this2 = _super2.call(this);
      var vertices = [];
      var normals = [];
      var quaternion = new _three.Quaternion();
      var up = new _three.Vector3(0, 1, 0);
      var point = new _three.Vector3();
      var tangent = new _three.Vector3(); // shapes

      var tube1 = [new _three.Vector3(0, 0.05, -0.05), new _three.Vector3(0, 0.05, 0.05), new _three.Vector3(0, -0.05, 0)];
      var tube2 = [new _three.Vector3(-0.05, 0, 0.05), new _three.Vector3(-0.05, 0, -0.05), new _three.Vector3(0.05, 0, 0)];
      var tube3 = [new _three.Vector3(0.05, 0, -0.05), new _three.Vector3(0.05, 0, 0.05), new _three.Vector3(-0.05, 0, 0)];
      var vector1 = new _three.Vector3();
      var vector2 = new _three.Vector3();
      var vector3 = new _three.Vector3();
      var vector4 = new _three.Vector3();
      var normal1 = new _three.Vector3();
      var normal2 = new _three.Vector3();
      var normal3 = new _three.Vector3();
      var normal4 = new _three.Vector3();

      function extrudeShape(shape, fromPoint, toPoint) {
        for (var j = 0, jl = shape.length; j < jl; j++) {
          var point1 = shape[j];
          var point2 = shape[(j + 1) % jl];
          vector1.copy(point1);
          vector1.applyQuaternion(quaternion);
          vector1.add(fromPoint);
          vector2.copy(point2);
          vector2.applyQuaternion(quaternion);
          vector2.add(fromPoint);
          vector3.copy(point2);
          vector3.applyQuaternion(quaternion);
          vector3.add(toPoint);
          vector4.copy(point1);
          vector4.applyQuaternion(quaternion);
          vector4.add(toPoint);
          vertices.push(vector1.x, vector1.y, vector1.z);
          vertices.push(vector2.x, vector2.y, vector2.z);
          vertices.push(vector4.x, vector4.y, vector4.z);
          vertices.push(vector2.x, vector2.y, vector2.z);
          vertices.push(vector3.x, vector3.y, vector3.z);
          vertices.push(vector4.x, vector4.y, vector4.z); //

          normal1.copy(point1);
          normal1.applyQuaternion(quaternion);
          normal1.normalize();
          normal2.copy(point2);
          normal2.applyQuaternion(quaternion);
          normal2.normalize();
          normal3.copy(point2);
          normal3.applyQuaternion(quaternion);
          normal3.normalize();
          normal4.copy(point1);
          normal4.applyQuaternion(quaternion);
          normal4.normalize();
          normals.push(normal1.x, normal1.y, normal1.z);
          normals.push(normal2.x, normal2.y, normal2.z);
          normals.push(normal4.x, normal4.y, normal4.z);
          normals.push(normal2.x, normal2.y, normal2.z);
          normals.push(normal3.x, normal3.y, normal3.z);
          normals.push(normal4.x, normal4.y, normal4.z);
        }
      }

      var fromPoint = new _three.Vector3();
      var toPoint = new _three.Vector3();

      for (var i = 1; i <= divisions; i++) {
        point.copy(curve.getPointAt(i / divisions));
        tangent.copy(curve.getTangentAt(i / divisions));
        var angle = Math.atan2(tangent.x, tangent.z);
        quaternion.setFromAxisAngle(up, angle); //

        if (point.y > 10) {
          fromPoint.set(-0.75, -0.35, 0);
          fromPoint.applyQuaternion(quaternion);
          fromPoint.add(point);
          toPoint.set(0.75, -0.35, 0);
          toPoint.applyQuaternion(quaternion);
          toPoint.add(point);
          extrudeShape(tube1, fromPoint, toPoint);
          fromPoint.set(-0.7, -0.3, 0);
          fromPoint.applyQuaternion(quaternion);
          fromPoint.add(point);
          toPoint.set(-0.7, -point.y, 0);
          toPoint.applyQuaternion(quaternion);
          toPoint.add(point);
          extrudeShape(tube2, fromPoint, toPoint);
          fromPoint.set(0.7, -0.3, 0);
          fromPoint.applyQuaternion(quaternion);
          fromPoint.add(point);
          toPoint.set(0.7, -point.y, 0);
          toPoint.applyQuaternion(quaternion);
          toPoint.add(point);
          extrudeShape(tube3, fromPoint, toPoint);
        } else {
          fromPoint.set(0, -0.2, 0);
          fromPoint.applyQuaternion(quaternion);
          fromPoint.add(point);
          toPoint.set(0, -point.y, 0);
          toPoint.applyQuaternion(quaternion);
          toPoint.add(point);
          extrudeShape(tube3, fromPoint, toPoint);
        }
      }

      _this2.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));

      _this2.setAttribute('normal', new _three.BufferAttribute(new Float32Array(normals), 3));

      return _this2;
    }

    return _createClass(RollerCoasterLiftersGeometry);
  }(_three.BufferGeometry);

  _exports.RollerCoasterLiftersGeometry = RollerCoasterLiftersGeometry;

  var RollerCoasterShadowGeometry = /*#__PURE__*/function (_BufferGeometry3) {
    _inherits(RollerCoasterShadowGeometry, _BufferGeometry3);

    var _super3 = _createSuper(RollerCoasterShadowGeometry);

    function RollerCoasterShadowGeometry(curve, divisions) {
      var _this3;

      _classCallCheck(this, RollerCoasterShadowGeometry);

      _this3 = _super3.call(this);
      var vertices = [];
      var up = new _three.Vector3(0, 1, 0);
      var forward = new _three.Vector3();
      var quaternion = new _three.Quaternion();
      var prevQuaternion = new _three.Quaternion();
      prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
      var point = new _three.Vector3();
      var prevPoint = new _three.Vector3();
      prevPoint.copy(curve.getPointAt(0));
      prevPoint.y = 0;
      var vector1 = new _three.Vector3();
      var vector2 = new _three.Vector3();
      var vector3 = new _three.Vector3();
      var vector4 = new _three.Vector3();

      for (var i = 1; i <= divisions; i++) {
        point.copy(curve.getPointAt(i / divisions));
        point.y = 0;
        forward.subVectors(point, prevPoint);
        var angle = Math.atan2(forward.x, forward.z);
        quaternion.setFromAxisAngle(up, angle);
        vector1.set(-0.3, 0, 0);
        vector1.applyQuaternion(quaternion);
        vector1.add(point);
        vector2.set(0.3, 0, 0);
        vector2.applyQuaternion(quaternion);
        vector2.add(point);
        vector3.set(0.3, 0, 0);
        vector3.applyQuaternion(prevQuaternion);
        vector3.add(prevPoint);
        vector4.set(-0.3, 0, 0);
        vector4.applyQuaternion(prevQuaternion);
        vector4.add(prevPoint);
        vertices.push(vector1.x, vector1.y, vector1.z);
        vertices.push(vector2.x, vector2.y, vector2.z);
        vertices.push(vector4.x, vector4.y, vector4.z);
        vertices.push(vector2.x, vector2.y, vector2.z);
        vertices.push(vector3.x, vector3.y, vector3.z);
        vertices.push(vector4.x, vector4.y, vector4.z);
        prevPoint.copy(point);
        prevQuaternion.copy(quaternion);
      }

      _this3.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));

      return _this3;
    }

    return _createClass(RollerCoasterShadowGeometry);
  }(_three.BufferGeometry);

  _exports.RollerCoasterShadowGeometry = RollerCoasterShadowGeometry;

  var SkyGeometry = /*#__PURE__*/function (_BufferGeometry4) {
    _inherits(SkyGeometry, _BufferGeometry4);

    var _super4 = _createSuper(SkyGeometry);

    function SkyGeometry() {
      var _this4;

      _classCallCheck(this, SkyGeometry);

      _this4 = _super4.call(this);
      var vertices = [];

      for (var i = 0; i < 100; i++) {
        var x = Math.random() * 800 - 400;
        var y = Math.random() * 50 + 50;
        var z = Math.random() * 800 - 400;
        var size = Math.random() * 40 + 20;
        vertices.push(x - size, y, z - size);
        vertices.push(x + size, y, z - size);
        vertices.push(x - size, y, z + size);
        vertices.push(x + size, y, z - size);
        vertices.push(x + size, y, z + size);
        vertices.push(x - size, y, z + size);
      }

      _this4.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));

      return _this4;
    }

    return _createClass(SkyGeometry);
  }(_three.BufferGeometry);

  _exports.SkyGeometry = SkyGeometry;

  var TreesGeometry = /*#__PURE__*/function (_BufferGeometry5) {
    _inherits(TreesGeometry, _BufferGeometry5);

    var _super5 = _createSuper(TreesGeometry);

    function TreesGeometry(landscape) {
      var _this5;

      _classCallCheck(this, TreesGeometry);

      _this5 = _super5.call(this);
      var vertices = [];
      var colors = [];
      var raycaster = new _three.Raycaster();
      raycaster.ray.direction.set(0, -1, 0);

      for (var i = 0; i < 2000; i++) {
        var x = Math.random() * 500 - 250;
        var z = Math.random() * 500 - 250;
        raycaster.ray.origin.set(x, 50, z);
        var intersections = raycaster.intersectObject(landscape);
        if (intersections.length === 0) continue;
        var y = intersections[0].point.y;
        var height = Math.random() * 5 + 0.5;
        var angle = Math.random() * Math.PI * 2;
        vertices.push(x + Math.sin(angle), y, z + Math.cos(angle));
        vertices.push(x, y + height, z);
        vertices.push(x + Math.sin(angle + Math.PI), y, z + Math.cos(angle + Math.PI));
        angle += Math.PI / 2;
        vertices.push(x + Math.sin(angle), y, z + Math.cos(angle));
        vertices.push(x, y + height, z);
        vertices.push(x + Math.sin(angle + Math.PI), y, z + Math.cos(angle + Math.PI));
        var random = Math.random() * 0.1;

        for (var j = 0; j < 6; j++) {
          colors.push(0.2 + random, 0.4 + random, 0);
        }
      }

      _this5.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));

      _this5.setAttribute('color', new _three.BufferAttribute(new Float32Array(colors), 3));

      return _this5;
    }

    return _createClass(TreesGeometry);
  }(_three.BufferGeometry);

  _exports.TreesGeometry = TreesGeometry;
});