awv3/session/helpers.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.normalizeName = exports.buildFeaturePath = exports.createObserver = exports.arrayDiff = exports.pack = 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 _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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 _pako = require('pako');

var _pako2 = _interopRequireDefault(_pako);

var _base64Arraybuffer = require('base64-arraybuffer');

var _base64Arraybuffer2 = _interopRequireDefault(_base64Arraybuffer);

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 (_Object) {
    (0, _inherits3.default)(Pool, _Object);

    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 _object2.default();
        _this.temporary.name = name + '.temporary';
        _this.temporary.updateParentMaterials = false;
        _this.temporary.measurable = 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: 'fadeIn',
        value: function fadeIn(options) {
            var _this2 = this;

            this.updateMaterials();
            this.defaults = this.preset;

            var edgeOpacity = this.session.options.materials.edgeOpacity;
            var edgeColor = this.session.options.materials.edgeColor;

            options = (0, _extends3.default)({}, this.preset, options);

            this.materials.all.forEach(function (item) {
                var opacity = 1,
                    color = item.color;
                if (item.meta) {
                    color = new (Function.prototype.bind.apply(THREE.Color, [null].concat((0, _toConsumableArray3.default)(item.meta.material.color))))();
                    opacity = item.meta.material.opacity;
                }

                if (item.type.indexOf('Line') > -1) {
                    opacity = edgeOpacity !== 'undefined' ? edgeOpacity : opacity;
                    color = edgeColor !== 'undefined' ? edgeColor : color;
                }

                item.animate({
                    opacity: opacity,
                    color: color
                }).start(options.duration);
                _this2.setRenderOrder(options.renderOrder);
            });
        }
    }, {
        key: 'fadeOut',
        value: function fadeOut(options) {
            this.updateMaterials();
            this.defaults = (0, _extends3.default)({}, this.preset, {
                meshOpacity: 0.3,
                lineOpacity: 0.3,
                renderOrder: _object2.default.RenderOrder.MeshesFirst
            }, options);
            this.animate({
                materials: {
                    meshes: [{ opacity: this.defaults.meshOpacity }],
                    lines: [{ opacity: this.defaults.lineOpacity }]
                }
            }).start(this.defaults.duration);
            this.setRenderOrder(this.defaults.renderOrder);
        }
    }]);
    return Pool;
}(_object2.default);

var ObjectPrototype = exports.ObjectPrototype = function (_Object2) {
    (0, _inherits3.default)(ObjectPrototype, _Object2);

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

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

        _this3.session = session;
        _this3.pool = session.pool;
        _this3.on((0, _defineProperty3.default)({}, _object2.default.Events.Lifecycle.ChildAdded, function (_ref3) {
            var child = _ref3.child;

            child.updateMaterials().animate({
                materials: {
                    meshes: [{ opacity: _this3.pool.defaults.meshOpacity || 1 }],
                    lines: [{
                        opacity: _this3.pool.defaults.lineOpacity || typeof session.options.materials.edgeOpacity !== 'undefined' ? session.options.materials.edgeOpacity : 1
                    }]
                }
            }).from({
                materials: {
                    meshes: [{ opacity: 0 }],
                    lines: [{ opacity: 0 }]
                }
            }).start(_this3.pool.defaults.duration).easing(_easing.exponential.in);
            _this3.setRenderOrder(_this3.pool.defaults.renderOrder);
        }));
        return _this3;
    }

    return ObjectPrototype;
}(_object2.default);

// Packs ArrayBuffer into deflated base64 for ClassCAD stream consumption


var pack = exports.pack = function pack(buffer) {
    return _base64Arraybuffer2.default.encode(_pako2.default.deflate(buffer, { raw: true }));
};

// 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, '');
};