awv3/dist/plugins/dimension/handle.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.PositionValueHandle = exports.ValueHandle = exports.PositionHandle = exports.Handle = undefined;

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

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

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

var _get3 = _interopRequireDefault(_get2);

var _isInteger = require('babel-runtime/core-js/number/is-integer');

var _isInteger2 = _interopRequireDefault(_isInteger);

var _values = require('babel-runtime/core-js/object/values');

var _values2 = _interopRequireDefault(_values);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

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 _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _cloneDeep = require('lodash/cloneDeep');

var _cloneDeep2 = _interopRequireDefault(_cloneDeep);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

var _object2 = _interopRequireDefault(_object);

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 Handle = exports.Handle = function (_THREE$Mesh) {
    (0, _inherits3.default)(Handle, _THREE$Mesh);

    function Handle(geometry, material) {
        (0, _classCallCheck3.default)(this, Handle);

        var _this = (0, _possibleConstructorReturn3.default)(this, (Handle.__proto__ || (0, _getPrototypeOf2.default)(Handle)).call(this, geometry, material));

        _this.createInteraction({ priority: 1000, types: ['DimensionHandle'] });
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = (0, _getIterator3.default)((0, _values2.default)(_object2.default.Events)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var category = _step.value;
                var _iteratorNormalCompletion2 = true;
                var _didIteratorError2 = false;
                var _iteratorError2 = undefined;

                try {
                    for (var _iterator2 = (0, _getIterator3.default)((0, _values2.default)(category)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                        var event = _step2.value;

                        if (_this[event]) _this.on(event, _this[event].bind(_this), { sync: true });
                    }
                } catch (err) {
                    _didIteratorError2 = true;
                    _iteratorError2 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion2 && _iterator2.return) {
                            _iterator2.return();
                        }
                    } finally {
                        if (_didIteratorError2) {
                            throw _iteratorError2;
                        }
                    }
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }

        _this.draggedState = undefined;
        _this.text = undefined;
        return _this;
    }

    (0, _createClass3.default)(Handle, [{
        key: _object2.default.Events.Interaction.Hovered,
        value: function value(hitObject) {
            this.view.setCursor('grab');
            if (this.parent.plugin.selector) this.parent.plugin.selector.hover(hitObject);else this.animate({ material: { color: new THREE.Color(this.colors.accent), opacity: 0.6 } }).start(0);
        }
    }, {
        key: _object2.default.Events.Interaction.Unhovered,
        value: function value(hitObject) {
            if (this.parent.plugin.selector) this.parent.plugin.selector.unhover(hitObject);else this.animate({ material: { color: new THREE.Color(this.colors.primary), opacity: 0.3 } }).start(1000);
        }
    }, {
        key: _object2.default.Events.Interaction.Picked,
        value: function value(hitObject) {
            this.view.controls.enabled = false;
        }
    }, {
        key: _object2.default.Events.Interaction.Dragged,
        value: function value(hitObject) {
            this.view.setCursor('grabbing');
            var ray = hitObject.ray.clone().applyMatrix4(new THREE.Matrix4().getInverse(this.parent.matrixWorld));
            var position = ray.intersectPlane(new THREE.Plane(new THREE.Vector3(0, 0, 1)));
            var id = this.parent.userData.meta.id;
            if (!id) return;
            this.draggedState = (0, _cloneDeep2.default)(this.parent.plugin.connection.tree[id]);
            this.onDrag(this.draggedState, position);
            this.parent.updateFromState(this.draggedState);
        }
    }, {
        key: _object2.default.Events.Interaction.Dropped,
        value: function value(hitObject) {
            this.view.setCursor('grab');
            this.view.controls.enabled = true;
            if (!this.draggedState) return;
            this.onDrop(this.draggedState);
            this.draggedState = undefined;
            this.parent.plugin.afterSetCallback();
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(hitObject) {
            if (this.parent.plugin.selector) this.parent.plugin.selector.clicked(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Missed,
        value: function value(hitObject) {
            if (this.parent.plugin.selector) this.parent.plugin.selector.missed(hitObject);
        }
    }, {
        key: _object2.default.Events.Lifecycle.Rendered,
        value: function value() {
            var scale = this.view.calculateScaleFactor(this.getWorldPosition(), 1);
            this.onScale(scale);
        }

        // called when the dimension state changes, should update meshes

    }, {
        key: 'updateFromState',
        value: function updateFromState(state) {
            var textParts = [];
            if (!state.members.paramName.value.startsWith('_')) textParts.push(state.members.paramName.value);
            var num = state.previewValue !== undefined ? state.previewValue : state.id ? this.parent.plugin.getDimensionDescriptor(state.id).value : undefined;
            if (num !== undefined) textParts.push((0, _isInteger2.default)(num) ? String(num) : num.toFixed(2));
            this.text = textParts.join(' ');
        }

        // called from Object3.Events.Interaction.Dragged/Dropped, should update state from position

    }, {
        key: 'onDrag',
        value: function onDrag(state, position) {}

        // called from Object3.Events.Interaction.Dropped, should send state update to the server

    }, {
        key: 'onDrop',
        value: function onDrop(state) {}

        // called from Object3.Events.Lifecycle.Rendered, should scale meshes

    }, {
        key: 'onScale',
        value: function onScale(scale) {}
    }]);
    return Handle;
}(THREE.Mesh);

var PositionHandle = exports.PositionHandle = function (_Handle) {
    (0, _inherits3.default)(PositionHandle, _Handle);

    function PositionHandle(plugin) {
        (0, _classCallCheck3.default)(this, PositionHandle);

        var colors = plugin.session.globals.colors;

        var _this2 = (0, _possibleConstructorReturn3.default)(this, (PositionHandle.__proto__ || (0, _getPrototypeOf2.default)(PositionHandle)).call(this, new THREE.SphereBufferGeometry(1, 16, 16), new THREE.MeshBasicMaterial({ color: colors.primary, transparent: true, opacity: 0.3 })));

        _this2.colors = colors;
        return _this2;
    }

    (0, _createClass3.default)(PositionHandle, [{
        key: 'updateFromState',
        value: function updateFromState(state) {
            (0, _get3.default)(PositionHandle.prototype.__proto__ || (0, _getPrototypeOf2.default)(PositionHandle.prototype), 'updateFromState', this).call(this, state);
            this.position.fromArray(state.members.dimPt.value);
        }
    }, {
        key: 'onDrag',
        value: function onDrag(state, position) {
            position.toArray(state.members.dimPt.value);
        }
    }, {
        key: 'onDrop',
        value: function onDrop(state) {
            var value = '{' + state.members.dimPt.value.join(', ') + '}';
            this.parent.plugin.getMemberDescriptor(state.id, 'dimPt').expression = value;
        }
    }, {
        key: 'onScale',
        value: function onScale(scale) {
            this.scale.setScalar(7 * scale);
        }
    }]);
    return PositionHandle;
}(Handle);

var ValueHandle = exports.ValueHandle = function (_Handle2) {
    (0, _inherits3.default)(ValueHandle, _Handle2);

    function ValueHandle(plugin) {
        (0, _classCallCheck3.default)(this, ValueHandle);

        var colors = plugin.session.globals.colors;

        var _this3 = (0, _possibleConstructorReturn3.default)(this, (ValueHandle.__proto__ || (0, _getPrototypeOf2.default)(ValueHandle)).call(this, new THREE.SphereBufferGeometry(1.5, 16, 16), new THREE.MeshBasicMaterial({ color: colors.primary, transparent: true, opacity: 0.3 })));

        _this3.colors = colors;
        return _this3;
    }

    (0, _createClass3.default)(ValueHandle, [{
        key: 'updateFromState',
        value: function updateFromState(state) {
            (0, _get3.default)(ValueHandle.prototype.__proto__ || (0, _getPrototypeOf2.default)(ValueHandle.prototype), 'updateFromState', this).call(this, state);

            var _map = ['startPt', 'endPt', 'dimPt', 'cornerPt', 'center'].map(function (x) {
                return new THREE.Vector3().fromArray((state.members[x] || { value: [0, 0, 0] }).value);
            }),
                _map2 = (0, _slicedToArray3.default)(_map, 5),
                start = _map2[0],
                end = _map2[1],
                dim = _map2[2],
                corner = _map2[3],
                center = _map2[4];

            var nearend = (state.members.valHandlePos || {}).value ? start : end;
            switch (state.class) {
                case 'CC_AngularDimension':
                case 'CC_AngularFeatureDimension':
                    this.position.copy(nearend).sub(corner).setLength(corner.distanceTo(dim)).add(corner);
                    break;
                case 'CC_LinearDimension':
                case 'CC_LinearFeatureDimension':
                    var d = new THREE.Vector3(Math.cos(state.members.angle.value), Math.sin(state.members.angle.value), 0);
                    this.position.copy(nearend).sub(dim).projectOnVector(d).add(dim);
                    break;
                case 'CC_RadialDimension':
                case 'CC_RadialFeatureDimension':
                case 'CC_DiameterDimension':
                case 'CC_DiameterFeatureDimension':
                    this.position.copy(dim).sub(center).setLength(state.members.radius.value).add(center);
                    break;
            }
            this.visible = (state.members.isDriven || { value: 0 }).value === 0;
        }
    }, {
        key: 'onDrag',
        value: function onDrag(state, position) {
            var _map3 = ['startPt', 'endPt', 'dimPt', 'cornerPt', 'center'].map(function (x) {
                return new THREE.Vector3().fromArray((state.members[x] || { value: [0, 0, 0] }).value);
            }),
                _map4 = (0, _slicedToArray3.default)(_map3, 5),
                start = _map4[0],
                end = _map4[1],
                dim = _map4[2],
                corner = _map4[3],
                center = _map4[4];

            var _ref = (state.members.valHandlePos || {}).value ? [start, end] : [end, start],
                _ref2 = (0, _slicedToArray3.default)(_ref, 2),
                nearend = _ref2[0],
                farend = _ref2[1];

            switch (state.class) {
                case 'CC_AngularDimension':
                case 'CC_AngularFeatureDimension':
                    var toPolar = function toPolar(v) {
                        return v.sub(corner).set(Math.atan2(v.y, v.x), v.length(), 0);
                    };
                    var fromPolar = function fromPolar(v) {
                        return v.set(v.y * Math.cos(v.x), v.y * Math.sin(v.x), 0).add(corner);
                    };
                    toPolar(nearend);
                    toPolar(farend);
                    var diffAng = toPolar(position).x - nearend.x;
                    nearend.x += diffAng;
                    if (state.members.valHandleBehaviour.value) farend.x -= diffAng;
                    var angle = (nearend.x - farend.x) % (2 * Math.PI);
                    fromPolar(nearend);
                    fromPolar(farend);
                    start.toArray(state.members.startPt.value);
                    end.toArray(state.members.endPt.value);
                    if (!Boolean(state.members.ccw.value) ^ Boolean(state.members.valHandlePos.value)) angle = -angle;
                    if (angle < 0) angle += 2 * Math.PI;
                    if (this.parent.plugin.getDimensionDescriptor(state.id).hasA_R) angle = THREE.Math.radToDeg(angle);
                    state.previewValue = angle;
                    break;
                case 'CC_LinearDimension':
                case 'CC_LinearFeatureDimension':
                    var d = new THREE.Vector3(Math.cos(state.members.angle.value), Math.sin(state.members.angle.value), 0);
                    var diff = position.clone().sub(nearend).projectOnVector(d);
                    nearend.add(diff);
                    if (state.members.valHandleBehaviour.value) farend.sub(diff);
                    start.toArray(state.members.startPt.value);
                    end.toArray(state.members.endPt.value);
                    state.previewValue = Math.abs(end.clone().sub(start).dot(d));
                    break;
                case 'CC_RadialDimension':
                case 'CC_RadialFeatureDimension':
                    state.members.radius.value = center.distanceTo(position);
                    state.previewValue = state.members.radius.value;
                    break;
                case 'CC_DiameterDimension':
                case 'CC_DiameterFeatureDimension':
                    state.members.radius.value = center.distanceTo(position);
                    state.previewValue = 2 * state.members.radius.value;
                    break;
            }
        }
    }, {
        key: 'onDrop',
        value: function onDrop(state) {
            this.parent.plugin.getDimensionDescriptor(state.id).expression = state.previewValue.toFixed(2);
        }
    }, {
        key: 'onScale',
        value: function onScale(scale) {
            this.scale.setScalar(7 * scale);
        }
    }]);
    return ValueHandle;
}(Handle);

var PositionValueHandle = exports.PositionValueHandle = function (_ValueHandle) {
    (0, _inherits3.default)(PositionValueHandle, _ValueHandle);

    function PositionValueHandle() {
        (0, _classCallCheck3.default)(this, PositionValueHandle);
        return (0, _possibleConstructorReturn3.default)(this, (PositionValueHandle.__proto__ || (0, _getPrototypeOf2.default)(PositionValueHandle)).apply(this, arguments));
    }

    (0, _createClass3.default)(PositionValueHandle, [{
        key: 'onDrag',
        value: function onDrag(state, position) {
            position.toArray(state.members.dimPt.value);
            (0, _get3.default)(PositionValueHandle.prototype.__proto__ || (0, _getPrototypeOf2.default)(PositionValueHandle.prototype), 'onDrag', this).call(this, state, position);
        }
    }, {
        key: 'onDrop',
        value: function onDrop(state) {
            var value = '{' + state.members.dimPt.value.join(', ') + '}';
            this.parent.plugin.getMemberDescriptor(state.id, 'dimPt').expression = value;
            (0, _get3.default)(PositionValueHandle.prototype.__proto__ || (0, _getPrototypeOf2.default)(PositionValueHandle.prototype), 'onDrop', this).call(this, state);
        }
    }]);
    return PositionValueHandle;
}(ValueHandle);