bytev-charts/lib/plugin/three.js/examples/jsm/loaders/obj2/shared/MeshReceiver.js

基于echarts和JavaScript及ES6封装的一个可以直接调用的图表组件库，内置主题设计，简单快捷，且支持用户自定义配置； npm 安装方式: npm install bytev-charts 若启动提示还需额外install插件,则运行 npm install @babel/runtime-corejs2 即可;

import "core-js/modules/es.array.iterator.js";
import "core-js/modules/es.array-buffer.slice.js";
import "core-js/modules/es.object.to-string.js";
import "core-js/modules/es.typed-array.float32-array.js";
import "core-js/modules/es.typed-array.copy-within.js";
import "core-js/modules/es.typed-array.every.js";
import "core-js/modules/es.typed-array.fill.js";
import "core-js/modules/es.typed-array.filter.js";
import "core-js/modules/es.typed-array.find.js";
import "core-js/modules/es.typed-array.find-index.js";
import "core-js/modules/es.typed-array.for-each.js";
import "core-js/modules/es.typed-array.includes.js";
import "core-js/modules/es.typed-array.index-of.js";
import "core-js/modules/es.typed-array.iterator.js";
import "core-js/modules/es.typed-array.join.js";
import "core-js/modules/es.typed-array.last-index-of.js";
import "core-js/modules/es.typed-array.map.js";
import "core-js/modules/es.typed-array.reduce.js";
import "core-js/modules/es.typed-array.reduce-right.js";
import "core-js/modules/es.typed-array.reverse.js";
import "core-js/modules/es.typed-array.set.js";
import "core-js/modules/es.typed-array.slice.js";
import "core-js/modules/es.typed-array.some.js";
import "core-js/modules/es.typed-array.sort.js";
import "core-js/modules/es.typed-array.subarray.js";
import "core-js/modules/es.typed-array.to-locale-string.js";
import "core-js/modules/es.typed-array.to-string.js";
import "core-js/modules/es.typed-array.uint32-array.js";
import "core-js/modules/es.typed-array.uint16-array.js";
import "core-js/modules/es.function.name.js";
import "core-js/modules/es.number.to-fixed.js";

/**
 * Development repository: https://github.com/kaisalmen/WWOBJLoader
 */
import { BufferAttribute, BufferGeometry, LineSegments, Mesh, Points } from "../../../../../build/three.module.js";
/**
 *
 * @param {MaterialHandler} materialHandler
 * @constructor
 */

var MeshReceiver = function MeshReceiver(materialHandler) {
  this.logging = {
    enabled: false,
    debug: false
  };
  this.callbacks = {
    onProgress: null,
    onMeshAlter: null
  };
  this.materialHandler = materialHandler;
};

MeshReceiver.prototype = {
  constructor: MeshReceiver,

  /**
   * Enable or disable logging in general (except warn and error), plus enable or disable debug logging.
   *
   * @param {boolean} enabled True or false.
   * @param {boolean} debug True or false.
   */
  setLogging: function setLogging(enabled, debug) {
    this.logging.enabled = enabled === true;
    this.logging.debug = debug === true;
  },

  /**
   *
   * @param {Function} onProgress
   * @param {Function} onMeshAlter
   * @private
   */
  _setCallbacks: function _setCallbacks(onProgress, onMeshAlter) {
    if (onProgress !== null && onProgress !== undefined && onProgress instanceof Function) {
      this.callbacks.onProgress = onProgress;
    }

    if (onMeshAlter !== null && onMeshAlter !== undefined && onMeshAlter instanceof Function) {
      this.callbacks.onMeshAlter = onMeshAlter;
    }
  },

  /**
   * Builds one or multiple meshes from the data described in the payload (buffers, params, material info).
   *
   * @param {Object} meshPayload Raw mesh description (buffers, params, materials) used to build one to many meshes.
   * @returns {Mesh[]} mesh Array of {@link Mesh}
   */
  buildMeshes: function buildMeshes(meshPayload) {
    var meshName = meshPayload.params.meshName;
    var buffers = meshPayload.buffers;
    var bufferGeometry = new BufferGeometry();

    if (buffers.vertices !== undefined && buffers.vertices !== null) {
      bufferGeometry.setAttribute('position', new BufferAttribute(new Float32Array(buffers.vertices), 3));
    }

    if (buffers.indices !== undefined && buffers.indices !== null) {
      bufferGeometry.setIndex(new BufferAttribute(new Uint32Array(buffers.indices), 1));
    }

    if (buffers.colors !== undefined && buffers.colors !== null) {
      bufferGeometry.setAttribute('color', new BufferAttribute(new Float32Array(buffers.colors), 3));
    }

    if (buffers.normals !== undefined && buffers.normals !== null) {
      bufferGeometry.setAttribute('normal', new BufferAttribute(new Float32Array(buffers.normals), 3));
    } else {
      bufferGeometry.computeVertexNormals();
    }

    if (buffers.uvs !== undefined && buffers.uvs !== null) {
      bufferGeometry.setAttribute('uv', new BufferAttribute(new Float32Array(buffers.uvs), 2));
    }

    if (buffers.skinIndex !== undefined && buffers.skinIndex !== null) {
      bufferGeometry.setAttribute('skinIndex', new BufferAttribute(new Uint16Array(buffers.skinIndex), 4));
    }

    if (buffers.skinWeight !== undefined && buffers.skinWeight !== null) {
      bufferGeometry.setAttribute('skinWeight', new BufferAttribute(new Float32Array(buffers.skinWeight), 4));
    }

    var material, materialName, key;
    var materialNames = meshPayload.materials.materialNames;
    var createMultiMaterial = meshPayload.materials.multiMaterial;
    var multiMaterials = [];

    for (key in materialNames) {
      materialName = materialNames[key];
      material = this.materialHandler.getMaterial(materialName);
      if (createMultiMaterial) multiMaterials.push(material);
    }

    if (createMultiMaterial) {
      material = multiMaterials;
      var materialGroups = meshPayload.materials.materialGroups;
      var materialGroup;

      for (key in materialGroups) {
        materialGroup = materialGroups[key];
        bufferGeometry.addGroup(materialGroup.start, materialGroup.count, materialGroup.index);
      }
    }

    var meshes = [];
    var mesh;
    var callbackOnMeshAlterResult;
    var useOrgMesh = true;
    var geometryType = meshPayload.geometryType === null ? 0 : meshPayload.geometryType;

    if (this.callbacks.onMeshAlter) {
      callbackOnMeshAlterResult = this.callbacks.onMeshAlter({
        detail: {
          meshName: meshName,
          bufferGeometry: bufferGeometry,
          material: material,
          geometryType: geometryType
        }
      });
    } // here LoadedMeshUserOverride is required to be provided by the callback used to alter the results


    if (callbackOnMeshAlterResult) {
      if (callbackOnMeshAlterResult.isDisregardMesh()) {
        useOrgMesh = false;
      } else if (callbackOnMeshAlterResult.providesAlteredMeshes()) {
        for (var i in callbackOnMeshAlterResult.meshes) {
          meshes.push(callbackOnMeshAlterResult.meshes[i]);
        }

        useOrgMesh = false;
      }
    }

    if (useOrgMesh) {
      if (meshPayload.computeBoundingSphere) bufferGeometry.computeBoundingSphere();

      if (geometryType === 0) {
        mesh = new Mesh(bufferGeometry, material);
      } else if (geometryType === 1) {
        mesh = new LineSegments(bufferGeometry, material);
      } else {
        mesh = new Points(bufferGeometry, material);
      }

      mesh.name = meshName;
      meshes.push(mesh);
    }

    var progressMessage = meshPayload.params.meshName;

    if (meshes.length > 0) {
      var meshNames = [];

      for (var _i in meshes) {
        mesh = meshes[_i];
        meshNames[_i] = mesh.name;
      }

      progressMessage += ': Adding mesh(es) (' + meshNames.length + ': ' + meshNames + ') from input mesh: ' + meshName;
      progressMessage += ' (' + (meshPayload.progress.numericalValue * 100).toFixed(2) + '%)';
    } else {
      progressMessage += ': Not adding mesh: ' + meshName;
      progressMessage += ' (' + (meshPayload.progress.numericalValue * 100).toFixed(2) + '%)';
    }

    if (this.callbacks.onProgress) {
      this.callbacks.onProgress('progress', progressMessage, meshPayload.progress.numericalValue);
    }

    return meshes;
  }
};
/**
 * Object to return by callback onMeshAlter. Used to disregard a certain mesh or to return one to many meshes.
 * @class
 *
 * @param {boolean} disregardMesh=false Tell implementation to completely disregard this mesh
 * @param {boolean} disregardMesh=false Tell implementation that mesh(es) have been altered or added
 */

var LoadedMeshUserOverride = function LoadedMeshUserOverride(disregardMesh, alteredMesh) {
  this.disregardMesh = disregardMesh === true;
  this.alteredMesh = alteredMesh === true;
  this.meshes = [];
};

LoadedMeshUserOverride.prototype = {
  constructor: LoadedMeshUserOverride,

  /**
   * Add a mesh created within callback.
   *
   * @param {Mesh} mesh
   */
  addMesh: function addMesh(mesh) {
    this.meshes.push(mesh);
    this.alteredMesh = true;
  },

  /**
   * Answers if mesh shall be disregarded completely.
   *
   * @returns {boolean}
   */
  isDisregardMesh: function isDisregardMesh() {
    return this.disregardMesh;
  },

  /**
   * Answers if new mesh(es) were created.
   *
   * @returns {boolean}
   */
  providesAlteredMeshes: function providesAlteredMeshes() {
    return this.alteredMesh;
  }
};
export { MeshReceiver, LoadedMeshUserOverride };