awv3/session/index.js

⚡ AWV3 embedded CAD

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var observeActiveConnection = function () {
    var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(id, previous) {
        var activeConnection;
        return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
                switch (_context.prev = _context.next) {
                    case 0:
                        if (previous) this.pool.removeAsync(_connections.base.references[previous].pool);

                        if (!id) {
                            _context.next = 8;
                            break;
                        }

                        activeConnection = _connections.base.references[id];
                        _context.next = 5;
                        return this.pool.addAsync(activeConnection.pool);

                    case 5:
                        _context.next = 7;
                        return this.pool.viewFound();

                    case 7:
                        this.pool.view.updateBounds().controls.focus().zoom().rotate(0, Math.PI / 3);

                    case 8:
                    case 'end':
                        return _context.stop();
                }
            }
        }, _callee, this);
    }));

    return function observeActiveConnection(_x3, _x4) {
        return _ref.apply(this, arguments);
    };
}();

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _redux = require('redux');

var _reduxThunk = require('redux-thunk');

var _reduxThunk2 = _interopRequireDefault(_reduxThunk);

var _remove = require('lodash/remove');

var _remove2 = _interopRequireDefault(_remove);

var _isFunction = require('lodash/isFunction');

var _isFunction2 = _interopRequireDefault(_isFunction);

var _element = require('./element');

var _element2 = _interopRequireDefault(_element);

var _index = require('./store/index.js');

var _globals = require('./store/globals');

var _elements = require('./store/elements');

var _connections = require('./store/connections');

var _plugins = require('./store/plugins');

var _helpers = require('./helpers');

var _selector = require('./selection/selector');

var _connection = require('./connection');

var _connection2 = _interopRequireDefault(_connection);

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 Session = function () {
    function Session() {
        var _options,
            _this = this;

        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        (0, _classCallCheck3.default)(this, Session);


        var materials = options.materials || {};
        delete options.materials;

        this.options = (0, _extends3.default)({
            debug: false,
            updateMaterials: false,
            centerGeometry: false,
            pool: _helpers.Pool,
            poolOptions: {},
            objectPrototype: _helpers.ObjectPrototype,
            materials: (0, _extends3.default)({
                multi: true,
                shadows: true,
                edgeColor: undefined,
                edgeOpacity: undefined,
                meshes: {
                    shader: THREE.MeshPhysicalMaterial,
                    options: (_options = {
                        transparent: true,
                        fog: false,
                        emissive: new THREE.Color(0),
                        reflectivity: 1,
                        polygonOffset: true,
                        polygonOffsetFactor: 1,
                        polygonOffsetUnits: 1
                    }, (0, _defineProperty3.default)(_options, 'emissive', new THREE.Color(0)), (0, _defineProperty3.default)(_options, 'metalness', 0.7), (0, _defineProperty3.default)(_options, 'roughness', 0.7), (0, _defineProperty3.default)(_options, 'clearCoat', 0.6), (0, _defineProperty3.default)(_options, 'clearCoatRoughness', 0.6), (0, _defineProperty3.default)(_options, 'envMapIntensity', 0.5), _options)
                }
            }, materials)
        }, options);

        var composeEnhancers = this.options.debug && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : _redux.compose;
        this.store = options.store || (0, _redux.createStore)(_index.reducer, composeEnhancers((0, _redux.applyMiddleware)(_reduxThunk2.default) /*, batchedSubscribe(batchedUpdates)*/));

        // Support hot reloading reducers
        if (process.env.NODE_ENV !== 'production' && !options.store && module.hot) {
            module.hot.accept(['./store/globals', './store/plugins', './store/elements', './store/connections', './store/index'], function () {
                return _this.store.replaceReducer(require('./store/index.js').reducer);
            });
        }

        this.pool = new _helpers.Pool(this);
        this.defaultPrototype;
        this.prototypes = {};
        this.layerNames = [];
        this.observe = (0, _helpers.createObserver)(this.store, this.getState.bind(this));
        this.selector = new _selector.Selector(this, options);

        // Global observers
        this.observe(function (state) {
            return state.globals.activeConnection;
        }, observeActiveConnection.bind(this));

        options.resources && this.addResources(options.resources);
        options.prototypes && this.registerPrototypes(options.prototypes);
        options.defaultPrototype && this.registerDefaultPrototype(options.defaultPrototype);

        // Add a global keylistener that will forward events to a plugins console
        var keydownEventHandler = keydownEvent.bind(this);
        document.addEventListener("keydown", keydownEventHandler);
    }

    (0, _createClass3.default)(Session, [{
        key: 'showLayer',
        value: function showLayer() {
            var _this2 = this;

            var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

            this.layerNames = Array.isArray(args) ? args : [args];
            this.pool.traverse(function (obj) {
                if (obj.material) {
                    if (obj.material instanceof THREE.MultiMaterial) {
                        obj.material.materials.forEach(function (mat) {
                            return mat.visible = mat.meta ? _this2.layerNames.length == 0 || _this2.layerNames.indexOf(mat.meta.layer) > -1 : mat.visible;
                        });
                    } else if (obj.material.meta) {
                        obj.material.visible = _this2.layerNames.length == 0 || _this2.layerNames.indexOf(obj.material.meta.layer) > -1;
                    }
                }
            });
            this.pool.view.invalidate();
        }
    }, {
        key: 'isVisibleLayer',
        value: function isVisibleLayer(layerName) {
            if (this.layerNames.length === 0 || this.layerNames.indexOf(layerName) > -1) return true;
            return false;
        }
    }, {
        key: 'getState',
        value: function getState() {
            return this.store.getState() || {};
        }
    }, {
        key: 'dispatch',
        value: function dispatch(action) {
            return this.store.dispatch(action);
        }
    }, {
        key: 'registerDefaultPrototype',
        value: function registerDefaultPrototype(prototype) {
            this.defaultPrototype = prototype;
        }
    }, {
        key: 'registerPrototypes',
        value: function registerPrototypes(map) {
            this.prototypes = (0, _extends3.default)({}, this.prototypes, map);
        }
    }, {
        key: 'findFeaturePlugin',
        value: function findFeaturePlugin(id) {
            return this.featurePlugins.find(function (item) {
                return item.id === id;
            });
        }
    }, {
        key: 'addResources',
        value: function addResources(map) {
            this.dispatch(_globals.actions.addResources(map));
        }
    }, {
        key: 'addConnection',
        value: function addConnection(name) {
            var connection = new _connection2.default(this, { name: name });
            this.store.dispatch(_globals.actions.setActiveConnection(connection.id));
            return connection;
        }
    }, {
        key: 'resolveResource',
        value: function resolveResource(name, plugin) {
            var resource = void 0;
            var scope = this.plugins[plugin];
            if (scope) resource = scope.resources[name];
            if (!resource) resource = this.globals.resources[name];
            return resource;
        }
    }, {
        key: 'resolveTree',
        value: function resolveTree(args) {
            var id = this.globals.activeConnection;
            var connection = _connections.base.references[id];
            return connection.resolveTree(args);
        }
    }, {
        key: 'state',
        get: function get() {
            return this.getState();
        }
    }, {
        key: 'globals',
        get: function get() {
            return this.state.globals;
        }
    }, {
        key: 'plugins',
        get: function get() {
            return this.state.plugins;
        }
    }, {
        key: 'elements',
        get: function get() {
            return this.state.elements;
        }
    }, {
        key: 'connections',
        get: function get() {
            return this.state.connections;
        }
    }, {
        key: 'collections',
        get: function get() {
            return this.state.collections;
        }

        // Computed props

    }, {
        key: 'activeConnection',
        get: function get() {
            return this.state.connections[this.state.globals.activeConnection];
        }
    }, {
        key: 'activePlugin',
        get: function get() {
            var _this3 = this;

            return this.plugins[this.activeConnection.plugins.find(function (item) {
                return _this3.plugins[item].feature === _this3.activeConnection.activeFeature;
            })];
        }
    }, {
        key: 'tree',
        get: function get() {
            return this.activeConnection.tree;
        }
    }, {
        key: 'activeConnectionClass',
        get: function get() {
            return _connections.base.references[this.globals.activeConnection];
        }
    }, {
        key: 'activePluginClass',
        get: function get() {
            return _plugins.base.references[this.activePlugin.id];
        }
    }]);
    return Session;
}();
//import { batchedSubscribe } from 'redux-batched-subscribe';

//import { unstable_batchedUpdates as batchedUpdates } from 'react-dom';


exports.default = Session;


function checkElements(session, elements) {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
        for (var _iterator = (0, _getIterator3.default)(elements), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var key = _step.value;

            var element = session.elements[key];
            if (element.type === _element2.default.Type.Console) {
                session.store.dispatch(_elements.actions.update(element.id, { focus: true }));
                session.store.dispatch(_elements.actions.event(element.id, event));
                return true;
            } else if (element.type === _element2.default.Type.Group && checkElements(session, element.children)) {
                return true;
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
            }
        } finally {
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }

    return false;
}

function keydownEvent(event) {
    var target = event.target;
    if (!(target instanceof HTMLInputElement)) {
        for (var key in this.plugins) {
            var plugin = this.plugins[key];
            if (plugin.enabled && !plugin.collapsed && checkElements(this, plugin.elements)) {
                return;
            }
        }
    }
}