awv3/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 = typeof _defaults2.default.renderOrder.LineSegments !== "undefined" ? _defaults2.default.renderOrder.LineSegments : 100;
    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 = [];

    if (options.materials.multi) {
        geom.material = new THREE.MultiMaterial(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 material = new options.materials.lines.shader((0, _extends3.default)({
                color: options.materials.edgeColor || new THREE.Color(group.color[0] / 255, group.color[1] / 255, group.color[2] / 255),
                opacity: typeof options.materials.edgeOpacity !== "undefined" ? options.materials.edgeOpacity : data.properties.opacity
            }, options.materials.lines.options));
            material.meta = group.meta;
            material.parent = geom;
            return material;
        }));
    } else {

        geom.material = new options.materials.lines.shader((0, _extends3.default)({
            color: options.materials.edgeColor || new THREE.Color(data.properties.color[0] / 255, data.properties.color[1] / 255, data.properties.color[2] / 255),
            opacity: typeof options.materials.edgeOpacity !== "undefined" ? options.materials.edgeOpacity : data.properties.opacity
        }, options.materials.lines.options));
        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 = typeof _defaults2.default.renderOrder.Mesh !== "undefined" ? _defaults2.default.renderOrder.Mesh : 0;
    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 && geometry.addAttribute('uv', new THREE.BufferAttribute(data.mesh.uvs, 2));
    }

    // Create materials
    if (options.materials.multi) {
        geom.material = new THREE.MultiMaterial(groups.map(function (group) {
            convertVectors(group.meta);
            var material = new options.materials.meshes.shader((0, _extends3.default)({
                color: new THREE.Color(group.color[0] / 255, group.color[1] / 255, group.color[2] / 255),
                opacity: typeof group.opacity !== "undefined" ? group.opacity : data.properties.opacity,
                envMap: options.materials.envMap || null
            }, options.materials.meshes.options));
            material.meta = group.meta;
            material.parent = geom;
            return material;
        }));
    } else {

        geom.material = new options.materials.meshes.shader((0, _extends3.default)({
            color: new THREE.Color(data.properties.color[0] / 255, data.properties.color[1] / 255, data.properties.color[2] / 255),
            opacity: data.properties.opacity,
            envMap: options.materials.envMap || null
        }, options.materials.meshes.options));

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