awv3/dist/three/raycaster.js

⚡ AWV3 embedded CAD

'use strict';

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

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 _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

    function Raycaster(interaction) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { approach: Raycaster.Approach.FirstMatch };
        (0, _classCallCheck3.default)(this, Raycaster);

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

        _this.interaction = interaction;
        _this.view = interaction.view;
        _this.linePrecision = 1.5;
        return _this;
    }

    (0, _createClass3.default)(Raycaster, [{
        key: 'isActuallyVisible',
        value: function isActuallyVisible(obj) {
            while (obj) {
                if (obj.visible === false) return false;
                if (obj.material && obj.material.visible === false) return false;
                obj = obj.parent;
            }
            return true;
        }
    }, {
        key: 'castObjects',
        value: function castObjects(objects) {
            var intersects = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
            var filter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;

            for (var i = 0, l = objects.length, object; i < l; i++) {
                object = objects[i];
                if (
                // No filter, filter is empty, or object is part of filter
                (!filter || filter.length === 0 || filter.indexOf(object) >= 0) &&
                // must be interactive
                object.interactive &&
                // must have interaction
                object.interaction &&
                // must be enabled
                object.interaction.enabled &&
                // muste be activ (have interaction related listeners)
                object.interaction._active &&
                // must be visible
                this.isActuallyVisible(object)) {
                    // ... then we intersect
                    this.intersect(object, object.interaction.recursive, intersects, object.interaction.types, object);
                }
            }

            // Sort items after priority. The receiver has it, and each object can define one as well on the prototype.
            // If no priority has been given or if it yields 0, the distance will be used to determine the hits importance
            intersects.sort(function (a, b) {
                return (b.receiver.interaction.priority || 0) + b.object.interactionPriority - ((a.receiver.interaction.priority || 0) + a.object.interactionPriority) || a.distance - b.distance;
            });
            return intersects;
        }
    }, {
        key: 'intersect',
        value: function intersect(object, recursive, intersects, types, parent) {
            var op = true;

            // Inspect types
            if (!!types) {
                if (Array.isArray(types)) {
                    op = !(object.type !== 'Object3D' && object.type !== 'Group' && types.indexOf(object.type) == -1);
                } else if (typeof types === 'function') op = types(object);
            }

            // false op stops operation right here, undefined op at least proceeds with childs
            if (op == false) return;

            var count = intersects.length;

            // true op allows raycast
            if (op == true) object.raycast(this, intersects, parent.interaction.approach);

            if (intersects.length != count) {
                for (var i = count, intersect, l = intersects.length; i < l; i++) {
                    intersect = intersects[i];
                    intersect.receiver = parent;

                    // If the parent/receiver is not recursive data.object should point back to it
                    if (!parent.interaction.recursive) {
                        intersect.receiver.object = parent;
                    }
                }
            }

            // If the root is not recursive there's no point in iterating further
            if (!parent.interaction.recursive) return;

            for (var _i = 0, _l = object.children.length, child, isMultiMaterial; _i < _l; _i++) {
                child = object.children[_i];
                isMultiMaterial = Array.isArray(child.material);

                // To proceed, a child:
                if (
                // is visible
                child.visible &&
                // is interactive
                child.interactive && (
                // doesn't have a material
                !child.material ||
                // OR has a single material and it is visible
                !isMultiMaterial && child.material.visible === true ||
                // OR has many materials and the first is visible
                // TODO: is this really what we want? seems kind of random
                isMultiMaterial && child.material[0].visible === true)) {
                    this.intersect(child, true, intersects, types, parent);
                }
            }
        }
    }]);
    return Raycaster;
}(THREE.Raycaster);

// TODO: Deprecate approaches
// Do we really need to fork each objects raycast if it perhaps only brings a small benefit anyway?


exports.default = Raycaster;
Raycaster.Approach = {
    Default: 'Default'
};