awv3/plugins/dimension/graphics/base.js

⚡ AWV3 embedded CAD

'use strict';

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

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

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 pointGeometry = new THREE.SphereBufferGeometry(1, 32, 32);
var pointMaterial = new THREE.MeshBasicMaterial({ color: 0x28b4d7, transparent: true, opacity: 0.1 });
var lineGeometry = new THREE.CylinderBufferGeometry(1, 1, 1);
var lineMaterial = new THREE.MeshBasicMaterial({ color: 0xFF4444 });
var arcGeometry = new THREE.TorusBufferGeometry();
var arcMaterial = new THREE.MeshBasicMaterial({ color: 0xFF4444 });
var arrowGeometry = new THREE.ConeBufferGeometry(1, 1);
var arrowMaterial = new THREE.MeshBasicMaterial({ color: 0xFF4444 });

var BaseGraphics = function (_THREE$Object3D) {
    (0, _inherits3.default)(BaseGraphics, _THREE$Object3D);

    function BaseGraphics(plugin) {
        var nLines = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

        var _this$dimensionPoint$;

        var nArcs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        var nArrows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
        (0, _classCallCheck3.default)(this, BaseGraphics);

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

        _this.plugin = plugin;
        _this.dimensionPoint = new THREE.Mesh(pointGeometry, pointMaterial);
        _this.dimensionPoint.scale.set(1e-1, 1e-1, 1e-1);
        _this.add(_this.dimensionPoint);
        _this.dimensionPoint.createInteraction().on((_this$dimensionPoint$ = {}, (0, _defineProperty3.default)(_this$dimensionPoint$, _object2.default.Events.Interaction.Picked, function (hitObject) {
            this.view.controls.enabled = false;
        }), (0, _defineProperty3.default)(_this$dimensionPoint$, _object2.default.Events.Interaction.Dropped, function (hitObject) {
            this.view.controls.enabled = true;
            var id = this.parent.userData.meta.id,
                v = this.position;
            this.parent.plugin.connection.execute('VAR o; o=CADH_RealToId(' + id + '); o.OBJ_AssignExprOrVal("dimPt", {' + v.x + ', ' + v.y + ', ' + v.z + '});');
        }), (0, _defineProperty3.default)(_this$dimensionPoint$, _object2.default.Events.Interaction.Dragged, function (hitObject) {
            var ray = hitObject.ray.clone().applyMatrix4(new THREE.Matrix4().getInverse(this.parent.matrixWorld));
            ray.intersectPlane(new THREE.Plane(new THREE.Vector3(0, 0, 1)), this.position);
        }), _this$dimensionPoint$));
        if (nLines) {
            _this.lines = [];
            for (var i = 0; i < nLines; ++i) {
                _this.lines.push(new THREE.Mesh(lineGeometry, lineMaterial));
            }_this.add.apply(_this, (0, _toConsumableArray3.default)(_this.lines));
        }
        if (nArcs) {
            _this.arcs = [];
            for (var _i = 0; _i < nArcs; ++_i) {
                _this.arcs.push(new THREE.Mesh(arcGeometry, arcMaterial));
            }_this.add.apply(_this, (0, _toConsumableArray3.default)(_this.arcs));
        }
        if (nArrows) {
            _this.arrows = [];
            for (var _i2 = 0; _i2 < nArrows; ++_i2) {
                _this.arrows.push(new THREE.Mesh(arrowGeometry, arrowMaterial));
            }_this.add.apply(_this, (0, _toConsumableArray3.default)(_this.arrows));
        }
        _this.dimPos2 = new THREE.Vector2();
        _this.dimPos3 = _this.dimensionPoint.position;
        _this.text = "";
        _this.textNode = document.createElement('div');
        _this.textNode.setAttribute('style', 'position: absolute; display: inline-block; top: 0; left: 0; color: black; font-size: 12px; pointer-events: none;');
        _this.userData.meta = {};
        _this.viewFound().then(function (view) {
            return view.dom.appendChild(_this.textNode);
        });
        return _this;
    }

    (0, _createClass3.default)(BaseGraphics, [{
        key: 'destroy',
        value: function destroy() {
            if (this.textNode.parentElement) this.textNode.parentElement.removeChild(this.textNode);
            (0, _get3.default)(BaseGraphics.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseGraphics.prototype), 'destroy', this).call(this);
        }
    }, {
        key: 'updateLine',
        value: function updateLine(i, start, end) {
            var line = this.lines[i];
            // line.geometry describes a cylinder with axis from [0, -0.5, 0] to [0, 0.5, 0] and raidus 1
            line.position.lerpVectors(start, end, 0.5);
            line.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), end.clone().sub(start).normalize());
            line.scale.set(1e-2, start.distanceTo(end), 1e-2);
        }
    }, {
        key: 'updateArc',
        value: function updateArc(i, center, radius, startAngle, endAngle) {
            var arc = this.arcs[i];
            // can't reuse arcGeometry because arc angle is variable
            arc.geometry.dispose();
            arc.geometry = new THREE.TorusBufferGeometry(radius, 1e-2, undefined, 32, endAngle - startAngle);
            arc.position.copy(center);
            arc.quaternion.setFromAxisAngle(new THREE.Vector3(0, 0, 1), startAngle);
            arc.scale.set(1, 1, 1);
        }
    }, {
        key: 'updateArrow',
        value: function updateArrow(i, start, end) {
            var arrow = this.arrows[i];
            // arrow.geometry describes a cone with axis from [0, -0.5, 0] (r=1) to [0, 0.5, 0] (r=0)
            arrow.position.lerpVectors(start, end, 0.99);
            arrow.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), end.clone().sub(start).normalize());
            arrow.scale.set(5e-2, start.distanceTo(end) / 50, 5e-2);
        }
    }, {
        key: 'update',
        value: function update() {
            var pos2 = this.view.getPoint2(this.localToWorld(this.dimPos3.clone()));
            if (!this.dimPos2.equals(pos2)) {
                this.dimPos2.copy(pos2);
                this.textNode.style.transform = 'translate3d(calc(-50% + ' + pos2.x + 'px), calc(-50% + ' + pos2.y + 'px), 0)';
            }
            if (this.textNode.textContent !== this.text) this.textNode.textContent = this.text;
        }
    }, {
        key: 'updateCoordinateSystem',
        value: function updateCoordinateSystem(csys) {
            csys = csys.map(function (row) {
                return new THREE.Vector3().fromArray(row);
            });
            this.matrix.makeBasis(csys[1], csys[2], csys[3]);
            this.matrix.setPosition(csys[0]);
            this.matrix.decompose(this.position, this.quaternion, this.scale);
            this.matrixWorldNeedsUpdate = true;
            this.updateMatrixWorld();
        }
    }, {
        key: 'updateFromState',
        value: function updateFromState(state, tree) {
            this.userData.meta.id = state.id;
            this.updateCoordinateSystem(state.coordinateSystem);
            this.dimPos3.fromArray(state.members.dimPt.value);
            this.text = state.members.paramName.value;
            if (state.members.master) {
                var master = tree[state.members.master.value];
                this.text += "\n" + String(master.members[master.class === 'CC_Extrusion' ? state.name : 'value'].value);
            }
        }
    }]);
    return BaseGraphics;
}(THREE.Object3D);

exports.default = BaseGraphics;