awv3/dist/session/helpers.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.normalizeName = exports.buildFeaturePath = exports.createObserver = exports.arrayDiff = exports.ObjectPrototype = exports.Pool = undefined;

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

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

var _extends3 = _interopRequireDefault(_extends2);

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

var _get3 = _interopRequireDefault(_get2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

var _object2 = _interopRequireDefault(_object);

var _easing = require('../animation/easing');

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

    function Pool(_ref) {
        var session = _ref.session,
            _ref$name = _ref.name,
            name = _ref$name === undefined ? 'pool' : _ref$name;
        (0, _classCallCheck3.default)(this, Pool);

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

        _this.name = name;
        _this.session = session;
        _this.temporary = new THREE.Group();
        _this.temporary.name = name + '.temporary';
        _this.temporary.updateParentMaterials = false;
        (0, _get3.default)(Pool.prototype.__proto__ || (0, _getPrototypeOf2.default)(Pool.prototype), 'add', _this).call(_this, _this.temporary);
        _this.preset = { duration: 300, renderOrder: _object2.default.RenderOrder.Default };
        _this.defaults = _this.preset;
        return _this;
    }

    (0, _createClass3.default)(Pool, [{
        key: 'update',
        value: function update() {
            // ...
        }
    }, {
        key: 'fadeToDefaults',
        value: function fadeToDefaults(object) {
            var _this2 = this;

            return object.animate(object.mapMaterial(function (material) {
                if (material.type.startsWith('Mesh') && _this2.defaults.meshOpacity !== undefined) return { opacity: _this2.defaults.meshOpacity };else if (material.type.startsWith('Line') && _this2.defaults.lineOpacity !== undefined) return { opacity: _this2.defaults.lineOpacity };else return {};
            }));
        }
    }, {
        key: 'fadeIn',
        value: function fadeIn(options) {
            var _this3 = this;

            if (!this.session) return;

            var _defaults = this.defaults = (0, _extends3.default)({}, this.preset, options),
                renderOrder = _defaults.renderOrder,
                duration = _defaults.duration;

            this.traverse(function (object) {
                return object.material && _this3.fadeToDefaults(object).start(duration);
            });
            this.setRenderOrder(renderOrder);
        }
    }, {
        key: 'fadeOut',
        value: function fadeOut(options) {
            this.fadeIn((0, _extends3.default)({ meshOpacity: 0.3, lineOpacity: 0.3, renderOrder: _object2.default.RenderOrder.MeshesFirst }, options));
        }
    }]);
    return Pool;
}(THREE.Group);

var ObjectPrototype = exports.ObjectPrototype = function (_THREE$Group2) {
    (0, _inherits3.default)(ObjectPrototype, _THREE$Group2);

    function ObjectPrototype(_ref2) {
        var session = _ref2.session;
        (0, _classCallCheck3.default)(this, ObjectPrototype);

        var _this4 = (0, _possibleConstructorReturn3.default)(this, (ObjectPrototype.__proto__ || (0, _getPrototypeOf2.default)(ObjectPrototype)).call(this));

        _this4.session = session;

        if (_this4.session) {
            _this4.pool = session.pool;
        }
        return _this4;
    }

    (0, _createClass3.default)(ObjectPrototype, [{
        key: 'reset',
        value: function reset(child) {
            var _this5 = this;

            if (this.pool) {
                // This will fade the model from zero opacity to either its material-given default or to
                // various presets defined by this pool or its session
                child.traverse(function (object) {
                    return object.material && _this5.pool.fadeToDefaults(object).from(object.mapMaterial({ opacity: 0 })).easing(_easing.exponential.in).start(_this5.pool.defaults.duration);
                });
                child.setRenderOrder(this.pool.defaults.renderOrder);
            }
            return this;
        }
    }]);
    return ObjectPrototype;
}(THREE.Group);

// Helps detecting changes in two array-states


var arrayDiff = exports.arrayDiff = function arrayDiff() {
    var next = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    var current = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    var callbackNew = arguments[2];
    var callbackDeleted = arguments[3];

    var nextSet = new _set2.default(next);
    var currentSet = new _set2.default(current);
    var promises = [];

    if (callbackNew) {
        var newItems = next.filter(function (item) {
            return !currentSet.has(item);
        });
        if (newItems.length) {
            var results = callbackNew(newItems);
            if (results) {
                promises = results;
            }
        }
    }

    if (callbackDeleted) {
        var deletedItems = current.filter(function (item) {
            return !nextSet.has(item);
        });
        if (deletedItems.length) {
            var _results = callbackDeleted(deletedItems);
            if (_results) {
                promises = [].concat((0, _toConsumableArray3.default)(promises), (0, _toConsumableArray3.default)(_results));
            }
        }
    }

    return _promise2.default.all(promises);
};

// State observe with pre-select and user-select
var createObserver = exports.createObserver = function createObserver(store) {
    var preSelect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : store.getState;
    return function (userSelect, onChange) {
        var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        var _options$fireOnStart = options.fireOnStart,
            fireOnStart = _options$fireOnStart === undefined ? false : _options$fireOnStart,
            _options$unsubscribeO = options.unsubscribeOnUndefined,
            unsubscribeOnUndefined = _options$unsubscribeO === undefined ? false : _options$unsubscribeO,
            _options$onRemove = options.onRemove,
            onRemove = _options$onRemove === undefined ? undefined : _options$onRemove,
            _options$manager = options.manager,
            manager = _options$manager === undefined ? undefined : _options$manager;


        var _finish = void 0,
            unsubscribed = false;
        var preselect = void 0,
            state = void 0;
        if ((preselect = preSelect()) === undefined || (state = userSelect(preselect)) === undefined && unsubscribeOnUndefined) return function () {};

        var handleChange = function handleChange() {
            if (unsubscribed) return;
            // Get pre-selected state
            var previousState = state;
            // Unsubscribe if preselect or state is undefined
            if ((preselect = preSelect()) === undefined || (state = userSelect(preselect)) === undefined && unsubscribeOnUndefined) {
                // revert state so that finish calls onRemove on a good state
                state = previousState;
                return _finish();
            }
            if (state === previousState) return;
            onChange(state, previousState);
        };

        // Subscribe to store, fire on start, return hooked unsubscribe
        if (fireOnStart) {
            state = undefined; // so that onChange is called with prev === undefined
            handleChange();
        }
        var unsubscribe = store.subscribe(handleChange);

        _finish = function finish() {
            if (unsubscribed) return;
            unsubscribed = true;
            unsubscribe();
            onRemove && onRemove(state, _finish);
        };

        // Call manager, if available. This allows classes to track subscribes and clean up
        // in bulk once they are destroyed.
        if (manager) manager(_finish);

        return _finish;
    };
};

// Build ClassAD feature path (_O. ...)
var buildFeaturePath = exports.buildFeaturePath = function buildFeaturePath(tree, feature) {
    if ((typeof feature === 'undefined' ? 'undefined' : (0, _typeof3.default)(feature)) !== 'object') feature = tree[feature];
    var path = [normalizeName(feature.name)],
        parent = feature;
    while (parent && parent.parent > 1) {
        parent = tree[parent.parent];
        path.push(normalizeName(parent.name));
    }
    return '_O.' + path.reverse().join('.');
};

var normalizeName = exports.normalizeName = function normalizeName(name) {
    return name.replace(/(\s|-|\r?\n)/g, '');
};