awv3/dist/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 _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

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);

var _geomutils = require('../../sketcher/geomutils');

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.preview = new _graphics2.default('CC_AngularDimension', _this.sketcher.dimension);
        _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, sector: 0, reflex: false, dimPos: new THREE.Vector3() };
        _this.resolve = function () {};
        return _this;
    }

    (0, _createClass3.default)(AngleHandler, [{
        key: 'destroy',
        value: function destroy(options) {
            this.preview.destroy();
            (0, _get3.default)(AngleHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(AngleHandler.prototype), 'destroy', this).call(this, options);
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object.id === this.sketch.id;
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            this.resolve(this.tuv);
        }
    }, {
        key: 'cancel',
        value: function cancel() {
            this.resolve(undefined);
        }
    }, {
        key: 'onMouseMove',
        value: function onMouseMove() {
            this.updatePreview();
        }
    }, {
        key: 'onKeyUp',
        value: function onKeyUp() {
            this.updatePreview();
        }
    }, {
        key: 'onKeyDown',
        value: function onKeyDown() {
            this.updatePreview();
        }
    }, {
        key: 'setLines',
        value: function setLines(lines) {
            var _lines$map = lines.map(function (line) {
                return [line.startPoint.pos, line.endPoint.pos];
            }),
                _lines$map2 = (0, _slicedToArray3.default)(_lines$map, 2),
                _lines$map2$ = (0, _slicedToArray3.default)(_lines$map2[0], 2),
                p0s = _lines$map2$[0],
                p0e = _lines$map2$[1],
                _lines$map2$2 = (0, _slicedToArray3.default)(_lines$map2[1], 2),
                p1s = _lines$map2$2[0],
                p1e = _lines$map2$2[1];

            this.dir0.copy(p0e).sub(p0s).normalize();
            this.dir1.copy(p1e).sub(p1s).normalize();
            // ensure that ccw angle from dir0 to dir1 is between 0 and Math.PI
            if (ccwAngle(this.dir0, this.dir1) < 0) {
                var s = lines[0];
                lines[0] = lines[1];
                lines[1] = s;
                return this.setLines(lines);
            }
            this.intersectionPoint = (0, _geomutils.intersectLines)(p0s, this.dir0, p1s, this.dir1);
            this.updatePreview();
            this.preview.onRender();
        }
    }, {
        key: 'updatePreview',
        value: function updatePreview() {
            var point = this.getRecentMousePosition();
            var dir = point.clone().sub(this.intersectionPoint).normalize();
            var rightOf0 = ccwAngle(this.dir0, dir) < 0,
                leftOf1 = ccwAngle(this.dir1, dir) >= 0;
            this.tuv.sector = rightOf0 << 1 | rightOf0 ^ leftOf1;
            this.tuv.reflex = !!this.sketcher.view.input.keys.control;
            this.tuv.type = this.tuv.sector ^ this.tuv.reflex << 1;
            this.tuv.dimPos.copy(point);
            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.dir0).negate();
                        end.copy(this.dir1).negate();
                        break;
                    }
                case 3:
                    {
                        start.copy(this.dir1).negate();
                        end.copy(this.dir0);
                        break;
                    }
            }
            this.tuv.userValue = ofSign(ccwAngle(start, end), this.tuv.reflex);
            this.tuv.value = ofSign(ccwAngle(this.dir0, this.dir1));
            function f(v) {
                return { value: v.toArray() };
            }
            var state = {
                id: 0,
                class: 'CC_AngularDimension',
                coordinateSystem: this.sketch.state.coordinateSystem,
                previewValue: THREE.Math.radToDeg(this.tuv.userValue),
                members: {
                    startPt: f(start.add(this.intersectionPoint)),
                    endPt: f(end.add(this.intersectionPoint)),
                    dimPt: f(point),
                    cornerPt: f(this.intersectionPoint),
                    paramName: { value: '_' },
                    ccw: { value: !this.tuv.reflex },
                    extendToCorner: { value: true }
                }
            };
            this.preview.updateFromState(state);
        }
    }]);
    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 ofSign(a) {
    var neg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    if (neg && a > 0.0) a -= 2.0 * Math.PI;
    if (!neg && a < 0.0) a += 2.0 * Math.PI;
    return Math.abs(a);
}