awv3/plugins/sketcher/handlers/angle.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = undefined;

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get4 = require('babel-runtime/helpers/get');

var _get5 = _interopRequireDefault(_get4);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _object = require('../../../three/object3');

var _object2 = _interopRequireDefault(_object);

var _graphics = require('../../dimension/graphics/');

var _graphics2 = _interopRequireDefault(_graphics);

var _base = require('./base');

var _base2 = _interopRequireDefault(_base);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var AngleHandler = function (_BaseHandler) {
    (0, _inherits3.default)(AngleHandler, _BaseHandler);

    function AngleHandler() {
        var _ref;

        (0, _classCallCheck3.default)(this, AngleHandler);

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

        var _this = (0, _possibleConstructorReturn3.default)(this, (_ref = AngleHandler.__proto__ || (0, _getPrototypeOf2.default)(AngleHandler)).call.apply(_ref, [this].concat(args)));

        _this.sketcher.pool.add(_this.preview);
        _this.intersectionPoint = new THREE.Vector3();
        _this.dir0 = new THREE.Vector3();
        _this.dir1 = new THREE.Vector3();
        _this.tuv = { type: 0, userValue: 0, value: 0 };
        _this.resolve = function () {};
        return _this;
    }

    (0, _createClass3.default)(AngleHandler, [{
        key: 'addInteractions',
        value: function addInteractions() {
            var _get2,
                _this2 = this;

            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                args[_key2] = arguments[_key2];
            }

            (_get2 = (0, _get5.default)(AngleHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(AngleHandler.prototype), 'addInteractions', this)).call.apply(_get2, [this].concat(args));
            this.onMouseMove = function (event) {
                var mousemove = _this2.sketcher.view.input.recent.mousemove;
                var point2 = new THREE.Vector2(mousemove.offsetX, mousemove.offsetY);
                var line3 = _this2.sketcher.view.getViewLine3(point2);
                var ray = new THREE.Ray(line3.start, line3.end.sub(line3.start));
                ray.applyMatrix4(new THREE.Matrix4().getInverse(_this2.sketch.matrixWorld));
                var sketchPoint = ray.intersectPlane(new THREE.Plane(new THREE.Vector3(0, 0, 1)));
                _this2.move(sketchPoint);
            };
            this.preview = new _graphics2.default('CC_AngularDimension', this.sketcher.dimension);
            this.preview.dimensionPoint.on(_object2.default.Events.Interaction.Clicked, function (hitObject) {
                return _this2.resolve(_this2.tuv);
            });
            this.sketcher.view.input.on('mousemove', this.onMouseMove);
        }
    }, {
        key: 'removeInteractions',
        value: function removeInteractions() {
            var _get3;

            this.sketcher.view.input.removeListener('mousemove', this.onMouseMove);
            this.preview.destroy();

            for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
                args[_key3] = arguments[_key3];
            }

            (_get3 = (0, _get5.default)(AngleHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(AngleHandler.prototype), 'removeInteractions', this)).call.apply(_get3, [this].concat(args));
        }
    }, {
        key: 'setLines',
        value: function setLines(line0, line1) {
            var _map = [line0, line1].map(function (line) {
                return [line.startPoint.pos, line.endPoint.pos];
            }),
                _map2 = (0, _slicedToArray3.default)(_map, 2),
                _map2$ = (0, _slicedToArray3.default)(_map2[0], 2),
                p0s = _map2$[0],
                p0e = _map2$[1],
                _map2$2 = (0, _slicedToArray3.default)(_map2[1], 2),
                p1s = _map2$2[0],
                p1e = _map2$2[1];

            this.dir0.copy(p0e).sub(p0s).normalize();
            this.dir1.copy(p1e).sub(p1s).normalize();
            var ray0 = new THREE.Ray(p0s, this.dir0);
            var plane1 = new THREE.Plane().setFromCoplanarPoints(p1s, p1e, p1e.clone().setZ(1));
            // try to intersect both ray and its negation to set the intersection point
            ray0.intersectPlane(plane1, this.intersectionPoint);
            ray0.direction.negate();
            ray0.intersectPlane(plane1, this.intersectionPoint);
            // ensure that ccw angle from dir0 to dir1 is between 0 and Math.PI
            if (ccwAngle(this.dir0, this.dir1) < 0) {
                var t = this.dir0;
                this.dir0 = this.dir1;
                this.dir1 = t;
                // TODO switch entities in the constraint
            }
            this.move(new THREE.Vector3());
            this.preview.onRender();
        }
    }, {
        key: 'move',
        value: function move(point) {
            var dir = point.clone().sub(this.intersectionPoint).normalize();
            var rightOf0 = ccwAngle(this.dir0, dir) < 0,
                leftOf1 = ccwAngle(this.dir1, dir) >= 0;
            this.tuv.type = rightOf0 << 1 | rightOf0 ^ leftOf1;
            var start = new THREE.Vector3(),
                end = new THREE.Vector3();
            switch (this.tuv.type) {
                case 0:
                    {
                        start.copy(this.dir0);
                        end.copy(this.dir1);
                        break;
                    }
                case 1:
                    {
                        start.copy(this.dir1);
                        end.copy(this.dir0).negate();
                        break;
                    }
                case 2:
                    {
                        start.copy(this.dir1);
                        end.copy(this.dir0);
                        break;
                    }
                case 3:
                    {
                        start.copy(this.dir0).negate();
                        end.copy(this.dir1);
                        break;
                    }
            }
            this.tuv.userValue = positive(ccwAngle(start, end));
            this.tuv.value = positive(ccwAngle(this.dir0, this.dir1));
            function f(v) {
                return { value: v.toArray() };
            }
            var state = {
                id: 0,
                coordinateSystem: this.sketch.state.coordinateSystem,
                members: {
                    startPt: f(start.add(this.intersectionPoint)),
                    endPt: f(end.add(this.intersectionPoint)),
                    dimPt: f(point),
                    cornerPt: f(this.intersectionPoint),
                    paramName: { value: String(180 / Math.PI * this.tuv.userValue) },
                    ccw: { value: true }
                }
            };
            this.preview.updateFromState(state);
        }
    }, {
        key: 'click',
        value: function click() {}
    }]);
    return AngleHandler;
}(_base2.default);

exports.default = AngleHandler;


function ccwAngle(a, b) {
    return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);
}

function positive(a) {
    return a < 0 ? a + 2 * Math.PI : a;
}