awv3/dist/core/geometry.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _extends3 = _interopRequireDefault(_extends2);

exports.parseLine = parseLine;
exports.parseMesh = parseMesh;

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _defaults = require('./defaults');

var _defaults2 = _interopRequireDefault(_defaults);

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

function parseLine(data, context) {
    var options = context.options;
    var id = data.id,
        groups = data.line.groups;

    // Create mesh

    var geom = new THREE.LineSegments();
    geom.renderOrder = options.renderOrder.LineSegments;
    geom.userData = { id: 0, parentId: id, refs: groups.map(function (group) {
            return group.meta;
        }) };

    // Create geometry
    geom.geometry = new THREE.BufferGeometry();
    geom.geometry.addAttribute('position', new THREE.BufferAttribute(data.line.vertices, 3));
    geom.geometry.groups = [];

    // lineDistances have to apply to the entire object if a single dashed material is among it, it can't be
    // set in a groups scope individually
    data.line.distances && geom.geometry.addAttribute('lineDistance', new THREE.BufferAttribute(data.line.distances, 1));

    if (options.materials.multi) {
        geom.material = groups.map(function (group) {
            convertVectors(group.meta);
            geom.geometry.groups.push({
                start: group.start / 3,
                count: group.count / 3,
                materialIndex: group.index,
                meta: group.meta
            });

            var lineShader = options.lineShader;
            var lineOptions = options.lineShaderOptions;
            if (group.meta.material.linetype === 'DASHED') {
                lineShader = THREE.LineDashedMaterial;
                lineOptions = (0, _extends3.default)({}, lineOptions, {
                    dashSize: 2,
                    gapSize: 2
                });
            }

            group.meta.material.color = lineOptions.color || new (Function.prototype.bind.apply(THREE.Color, [null].concat((0, _toConsumableArray3.default)(group.meta.material.color))))();
            group.meta.material.opacity = typeof lineOptions.opacity !== 'undefined' ? lineOptions.opacity : group.meta.material.opacity;

            var material = new lineShader((0, _extends3.default)({}, lineOptions, {
                color: group.meta.material.color,
                opacity: group.meta.material.opacity
            }));
            material.meta = group.meta;
            material.parent = geom;
            return material;
        });
    } else {
        data.properties.material.color = options.lineShaderOptions.color || data.properties.material.color;
        data.properties.material.opacity = typeof options.lineShaderOptions.opacity !== 'undefined' ? options.lineShaderOptions.opacity : data.properties.material.opacity;

        geom.material = new options.lineShader((0, _extends3.default)({}, options.lineShaderOptions, {
            color: data.properties.material.color,
            opacity: data.properties.material.opacity
        }));
        geom.material.parent = geom;
    }

    return finalize(geom, data, groups);
}

function parseMesh(data, context) {
    var options = context.options;
    var id = data.id,
        groups = data.mesh.groups;

    // Create mesh

    var geom = new THREE.Mesh();
    if (options.materials.shadows) {
        geom.castShadow = true;
        geom.receiveShadow = true;
    }
    geom.renderOrder = options.renderOrder.Mesh;
    geom.userData = { id: 0, parentId: id, refs: groups.map(function (group) {
            return group.meta;
        }) };

    // Create geometry
    if (options.materials.multi) {
        geom.geometry = new THREE.Geometry();

        for (var index = 0, length = data.mesh.vertices.length / 3; index < length; index++) {
            geom.geometry.vertices.push(new THREE.Vector3(data.mesh.vertices[index * 3 + 0], data.mesh.vertices[index * 3 + 1], data.mesh.vertices[index * 3 + 2]));
        }var i1 = void 0,
            i2 = void 0,
            i3 = void 0,
            normal = void 0,
            groupCount = 0;
        var group = groups[groupCount++];
        for (var _index = 0, _length = data.mesh.indices.length / 3; _index < _length; _index++) {
            if (group.start + group.count <= _index * 3) group = groups[groupCount++];

            i1 = data.mesh.indices[_index * 3 + 0];
            i2 = data.mesh.indices[_index * 3 + 1];
            i3 = data.mesh.indices[_index * 3 + 2];

            normal = data.mesh.normals ? [new THREE.Vector3(data.mesh.normals[i1 * 3 + 0], data.mesh.normals[i1 * 3 + 1], data.mesh.normals[i1 * 3 + 2]), new THREE.Vector3(data.mesh.normals[i2 * 3 + 0], data.mesh.normals[i2 * 3 + 1], data.mesh.normals[i2 * 3 + 2]), new THREE.Vector3(data.mesh.normals[i3 * 3 + 0], data.mesh.normals[i3 * 3 + 1], data.mesh.normals[i3 * 3 + 2])] : undefined;

            geom.geometry.faces.push(new THREE.Face3(i1, i2, i3, normal, undefined, group.index));
        }

        if (!data.mesh.normals) geom.geometry.computeVertexNormals();
    } else {
        geom.geometry = new THREE.BufferGeometry();
        geom.geometry.addAttribute('position', new THREE.BufferAttribute(data.mesh.vertices, 3));
        geom.geometry.setIndex(new THREE.BufferAttribute(data.mesh.indices, 1));
        if (!!data.mesh.normals) geom.geometry.addAttribute('normal', new THREE.BufferAttribute(data.mesh.normals, 3));else geom.geometry.computeVertexNormals();
        !!data.mesh.uvs && geom.geometry.addAttribute('uv', new THREE.BufferAttribute(data.mesh.uvs, 2));
    }

    // Create materials
    if (options.materials.multi) {
        geom.material = groups.map(function (group) {
            convertVectors(group.meta);

            group.meta.material.color = options.meshShaderOptions.color || new (Function.prototype.bind.apply(THREE.Color, [null].concat((0, _toConsumableArray3.default)(group.meta.material.color))))();
            group.meta.material.opacity = typeof options.meshShaderOptions.opacity !== 'undefined' ? options.meshShaderOptions.opacity : group.meta.material.opacity;

            var material = new options.meshShader((0, _extends3.default)({}, options.meshShaderOptions, {
                color: group.meta.material.color,
                opacity: group.meta.material.opacity
            }));
            material.meta = group.meta;
            material.parent = geom;
            return material;
        });
    } else {
        data.properties.material.color = options.meshShaderOptions.color || data.properties.material.color;
        data.properties.material.opacity = typeof options.meshShaderOptions.opacity !== 'undefined' ? options.meshShaderOptions.opacity : data.properties.material.opacity;

        geom.material = new options.meshShader((0, _extends3.default)({}, options.meshShaderOptions, data.properties.material, {
            color: data.properties.material.color,
            opacity: data.properties.material.opacity
        }));

        geom.material.parent = geom;
    }

    return finalize(geom, data, groups);
}

function convertVectors(meta) {
    meta.box = new THREE.Box3(new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(meta.min))))(), new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(meta.max))))());
    delete meta.min;
    delete meta.max;
    for (var key in meta) {
        var item = meta[key];
        if (Array.isArray(item) && item.length == 3) meta[key] = new THREE.Vector3().fromArray(item);
    }
}

function finalize(geom, data, groups) {
    if (!!data.properties.box) {
        geom.geometry.boundingBox = data.properties.box;
        geom.geometry.boundingSphere = data.properties.sphere;
    } else {
        geom.geometry.computeBoundingBox();
        geom.geometry.computeBoundingSphere();
    }
    return geom;
}