awv3/plugins/sketcher/handlers/fillet.js

⚡ AWV3 embedded CAD

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _extends from "@babel/runtime/helpers/extends";
import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
import * as THREE from 'three';
import Object3 from '../../../three/object3';
import HoverHandler from './hover';
import FilletProcessor from '../fillet';
import { updateGeomObjectContainer } from '../preview';

var FilletHandler =
/*#__PURE__*/
function (_HoverHandler) {
  _inheritsLoose(FilletHandler, _HoverHandler);

  function FilletHandler(sketcher, name) {
    var _this;

    _this = _HoverHandler.call(this, sketcher, name) || this;
    _this.processor = new FilletProcessor(sketcher.activeSketch);
    _this.preview = [new THREE.Object3D(), new THREE.Object3D()];

    _this.sketcher.pool.add(_this.preview[0]);

    _this.sketcher.pool.add(_this.preview[1]);

    return _this;
  }

  var _proto = FilletHandler.prototype;

  _proto.destroy = function destroy() {
    var _HoverHandler$prototy;

    this.preview[0].destroy();
    this.preview[1].destroy();

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    (_HoverHandler$prototy = _HoverHandler.prototype.destroy).call.apply(_HoverHandler$prototy, [this].concat(args));
  };

  _proto.filterObjectsWithInteraction = function filterObjectsWithInteraction(object) {
    if (object.graphics === undefined) return false;
    if (object.isPoint() && !!this.processor.recognizeFilletableAngle(object.pos)) return true;
    if (object.isArc() && !!this.processor.recognizeFilletByArcOrEdge(object)) return true;
    return false;
  };

  _proto.calculateNewFilletData = function calculateNewFilletData(object) {
    if (object.isPoint()) {
      var info = this.processor.recognizeFilletableAngle(object.pos);
      if (!info) return null;
      var offset = 1 / 4 * Math.min(info.lines[0].startPoint.pos.distanceTo(info.lines[0].endPoint.pos), info.lines[1].startPoint.pos.distanceTo(info.lines[1].endPoint.pos));
      var params = this.processor.calculateFilletParams(info, {
        offset: offset
      });
      if (!params) return null;
      return {
        info: info,
        params: params
      };
    }
  };

  _proto[Object3.Events.Interaction.Hovered] = function (ccref, hitObject) {
    var object = hitObject.object,
        material = hitObject.material,
        first = hitObject.first;
    if (!first) return;
    this.sketcher.selector.hovered({
      object: object,
      material: material
    });

    if (ccref.isPoint()) {
      var data = this.calculateNewFilletData(ccref);
      if (!data) return;
      updateGeomObjectContainer(this.preview[0], _extends({
        coordinateSystem: this.sketch.graphics.matrix,
        scale: this.sketcher.graphicScale
      }, data.params));
    } else {
      var info = this.processor.recognizeFilletByArcOrEdge(ccref);

      for (var i = 0; i < 2; i++) {
        updateGeomObjectContainer(this.preview[i], {
          coordinateSystem: this.sketch.graphics.matrix,
          scale: this.sketcher.graphicScale,
          start: info.lineStarts[i].pos,
          end: info.vertex.pos
        });
      }
    }
  };

  _proto[Object3.Events.Interaction.Unhovered] = function (ccref, hitObject) {
    var object = hitObject.object,
        material = hitObject.material;
    this.sketcher.selector.unhovered({
      object: object,
      material: material
    });
    updateGeomObjectContainer(this.preview[0], {});
    updateGeomObjectContainer(this.preview[1], {});
  };

  _proto[Object3.Events.Interaction.Clicked] = function (object, hitObject) {
    var _this2 = this;

    if (!hitObject.first) return;
    var commands;

    if (object.isPoint()) {
      var data = this.calculateNewFilletData(object);
      if (!data) return;
      commands = this.processor.createNewFilletStatement(data.info, data.params);
    } else {
      //object = arc
      var info = this.processor.recognizeFilletByArcOrEdge(object);
      commands = this.processor.deleteFilletStatement(info);
    }

    updateGeomObjectContainer(this.preview[0], {});
    updateGeomObjectContainer(this.preview[1], {});
    return _asyncToGenerator(
    /*#__PURE__*/
    _regeneratorRuntime.mark(function _callee() {
      return _regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return Promise.resolve();

            case 2:
              _context.next = 4;
              return _this2.sketcher.run(commands);

            case 4:
              _context.next = 6;
              return _this2.sketcher.incrementalSolveConstraints();

            case 6:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this);
    }))();
  }; //TODO: perhaps remove?


  _proto[Object3.Events.Interaction.Picked] = function (object, hitObject) {
    if (!hitObject.first) return;
    this.sketcher.view.controls.enabled = false; //do not update camera when dragging
  };

  _proto[Object3.Events.Interaction.Dropped] = function (object, hitObject) {
    if (!hitObject.first) return;
    this.sketcher.view.controls.enabled = true;
  };

  return FilletHandler;
}(HoverHandler);

export { FilletHandler as default };