@things-factory/scene-visualizer 6.0.1 → 6.0.5

package/src/loaders/TGALoader.js

@@ -1,461 +0,0 @@
-/*
- * @author Daosheng Mu / https://github.com/DaoshengMu/
- * @author mrdoob / http://mrdoob.com/
- * @author takahirox / https://github.com/takahirox/
- */
-
-import * as THREE from 'three'
-
-function TGALoader(manager) {
-  this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager
-}
-
-TGALoader.prototype = {
-  constructor: TGALoader,
-
-  load: function(url, onLoad, onProgress, onError) {
-    var scope = this
-
-    var texture = new THREE.Texture()
-
-    var loader = new THREE.FileLoader(this.manager)
-    loader.setResponseType('arraybuffer')
-    loader.setPath(this.path)
-
-    loader.load(
-      url,
-      function(buffer) {
-        texture.image = scope.parse(buffer)
-        texture.needsUpdate = true
-
-        if (onLoad !== undefined) {
-          onLoad(texture)
-        }
-      },
-      onProgress,
-      onError
-    )
-
-    return texture
-  },
-
-  parse: function(buffer) {
-    // reference from vthibault, https://github.com/vthibault/roBrowser/blob/master/src/Loaders/Targa.js
-
-    function tgaCheckHeader(header) {
-      switch (header.image_type) {
-        // check indexed type
-
-        case TGA_TYPE_INDEXED:
-        case TGA_TYPE_RLE_INDEXED:
-          if (header.colormap_length > 256 || header.colormap_size !== 24 || header.colormap_type !== 1) {
-            console.error('THREE.TGALoader: Invalid type colormap data for indexed type.')
-          }
-          break
-
-        // check colormap type
-
-        case TGA_TYPE_RGB:
-        case TGA_TYPE_GREY:
-        case TGA_TYPE_RLE_RGB:
-        case TGA_TYPE_RLE_GREY:
-          if (header.colormap_type) {
-            console.error('THREE.TGALoader: Invalid type colormap data for colormap type.')
-          }
-          break
-
-        // What the need of a file without data ?
-
-        case TGA_TYPE_NO_DATA:
-          console.error('THREE.TGALoader: No data.')
-
-        // Invalid type ?
-
-        default:
-          console.error('THREE.TGALoader: Invalid type "%s".', header.image_type)
-      }
-
-      // check image width and height
-
-      if (header.width <= 0 || header.height <= 0) {
-        console.error('THREE.TGALoader: Invalid image size.')
-      }
-
-      // check image pixel size
-
-      if (header.pixel_size !== 8 && header.pixel_size !== 16 && header.pixel_size !== 24 && header.pixel_size !== 32) {
-        console.error('THREE.TGALoader: Invalid pixel size "%s".', header.pixel_size)
-      }
-    }
-
-    // parse tga image buffer
-
-    function tgaParse(use_rle, use_pal, header, offset, data) {
-      var pixel_data, pixel_size, pixel_total, palettes
-
-      pixel_size = header.pixel_size >> 3
-      pixel_total = header.width * header.height * pixel_size
-
-      // read palettes
-
-      if (use_pal) {
-        palettes = data.subarray(offset, (offset += header.colormap_length * (header.colormap_size >> 3)))
-      }
-
-      // read RLE
-
-      if (use_rle) {
-        pixel_data = new Uint8Array(pixel_total)
-
-        var c, count, i
-        var shift = 0
-        var pixels = new Uint8Array(pixel_size)
-
-        while (shift < pixel_total) {
-          c = data[offset++]
-          count = (c & 0x7f) + 1
-
-          // RLE pixels
-
-          if (c & 0x80) {
-            // bind pixel tmp array
-
-            for (i = 0; i < pixel_size; ++i) {
-              pixels[i] = data[offset++]
-            }
-
-            // copy pixel array
-
-            for (i = 0; i < count; ++i) {
-              pixel_data.set(pixels, shift + i * pixel_size)
-            }
-
-            shift += pixel_size * count
-          } else {
-            // raw pixels
-
-            count *= pixel_size
-            for (i = 0; i < count; ++i) {
-              pixel_data[shift + i] = data[offset++]
-            }
-            shift += count
-          }
-        }
-      } else {
-        // raw pixels
-
-        pixel_data = data.subarray(offset, (offset += use_pal ? header.width * header.height : pixel_total))
-      }
-
-      return {
-        pixel_data: pixel_data,
-        palettes: palettes
-      }
-    }
-
-    function tgaGetImageData8bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image, palettes) {
-      var colormap = palettes
-      var color,
-        i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i++) {
-          color = image[i]
-          imageData[(x + width * y) * 4 + 3] = 255
-          imageData[(x + width * y) * 4 + 2] = colormap[color * 3 + 0]
-          imageData[(x + width * y) * 4 + 1] = colormap[color * 3 + 1]
-          imageData[(x + width * y) * 4 + 0] = colormap[color * 3 + 2]
-        }
-      }
-
-      return imageData
-    }
-
-    function tgaGetImageData16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-      var color,
-        i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i += 2) {
-          color = image[i + 0] + (image[i + 1] << 8) // Inversed ?
-          imageData[(x + width * y) * 4 + 0] = (color & 0x7c00) >> 7
-          imageData[(x + width * y) * 4 + 1] = (color & 0x03e0) >> 2
-          imageData[(x + width * y) * 4 + 2] = (color & 0x001f) >> 3
-          imageData[(x + width * y) * 4 + 3] = color & 0x8000 ? 0 : 255
-        }
-      }
-
-      return imageData
-    }
-
-    function tgaGetImageData24bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-      var i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i += 3) {
-          imageData[(x + width * y) * 4 + 3] = 255
-          imageData[(x + width * y) * 4 + 2] = image[i + 0]
-          imageData[(x + width * y) * 4 + 1] = image[i + 1]
-          imageData[(x + width * y) * 4 + 0] = image[i + 2]
-        }
-      }
-
-      return imageData
-    }
-
-    function tgaGetImageData32bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-      var i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i += 4) {
-          imageData[(x + width * y) * 4 + 2] = image[i + 0]
-          imageData[(x + width * y) * 4 + 1] = image[i + 1]
-          imageData[(x + width * y) * 4 + 0] = image[i + 2]
-          imageData[(x + width * y) * 4 + 3] = image[i + 3]
-        }
-      }
-
-      return imageData
-    }
-
-    function tgaGetImageDataGrey8bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-      var color,
-        i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i++) {
-          color = image[i]
-          imageData[(x + width * y) * 4 + 0] = color
-          imageData[(x + width * y) * 4 + 1] = color
-          imageData[(x + width * y) * 4 + 2] = color
-          imageData[(x + width * y) * 4 + 3] = 255
-        }
-      }
-
-      return imageData
-    }
-
-    function tgaGetImageDataGrey16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-      var i = 0,
-        x,
-        y
-      var width = header.width
-
-      for (y = y_start; y !== y_end; y += y_step) {
-        for (x = x_start; x !== x_end; x += x_step, i += 2) {
-          imageData[(x + width * y) * 4 + 0] = image[i + 0]
-          imageData[(x + width * y) * 4 + 1] = image[i + 0]
-          imageData[(x + width * y) * 4 + 2] = image[i + 0]
-          imageData[(x + width * y) * 4 + 3] = image[i + 1]
-        }
-      }
-
-      return imageData
-    }
-
-    function getTgaRGBA(data, width, height, image, palette) {
-      var x_start, y_start, x_step, y_step, x_end, y_end
-
-      switch ((header.flags & TGA_ORIGIN_MASK) >> TGA_ORIGIN_SHIFT) {
-        default:
-        case TGA_ORIGIN_UL:
-          x_start = 0
-          x_step = 1
-          x_end = width
-          y_start = 0
-          y_step = 1
-          y_end = height
-          break
-
-        case TGA_ORIGIN_BL:
-          x_start = 0
-          x_step = 1
-          x_end = width
-          y_start = height - 1
-          y_step = -1
-          y_end = -1
-          break
-
-        case TGA_ORIGIN_UR:
-          x_start = width - 1
-          x_step = -1
-          x_end = -1
-          y_start = 0
-          y_step = 1
-          y_end = height
-          break
-
-        case TGA_ORIGIN_BR:
-          x_start = width - 1
-          x_step = -1
-          x_end = -1
-          y_start = height - 1
-          y_step = -1
-          y_end = -1
-          break
-      }
-
-      if (use_grey) {
-        switch (header.pixel_size) {
-          case 8:
-            tgaGetImageDataGrey8bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image)
-            break
-
-          case 16:
-            tgaGetImageDataGrey16bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image)
-            break
-
-          default:
-            console.error('THREE.TGALoader: Format not supported.')
-            break
-        }
-      } else {
-        switch (header.pixel_size) {
-          case 8:
-            tgaGetImageData8bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image, palette)
-            break
-
-          case 16:
-            tgaGetImageData16bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image)
-            break
-
-          case 24:
-            tgaGetImageData24bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image)
-            break
-
-          case 32:
-            tgaGetImageData32bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image)
-            break
-
-          default:
-            console.error('THREE.TGALoader: Format not supported.')
-            break
-        }
-      }
-
-      // Load image data according to specific method
-      // var func = 'tgaGetImageData' + (use_grey ? 'Grey' : '') + (header.pixel_size) + 'bits';
-      // func(data, y_start, y_step, y_end, x_start, x_step, x_end, width, image, palette );
-      return data
-    }
-
-    // TGA constants
-
-    var TGA_TYPE_NO_DATA = 0,
-      TGA_TYPE_INDEXED = 1,
-      TGA_TYPE_RGB = 2,
-      TGA_TYPE_GREY = 3,
-      TGA_TYPE_RLE_INDEXED = 9,
-      TGA_TYPE_RLE_RGB = 10,
-      TGA_TYPE_RLE_GREY = 11,
-      TGA_ORIGIN_MASK = 0x30,
-      TGA_ORIGIN_SHIFT = 0x04,
-      TGA_ORIGIN_BL = 0x00,
-      TGA_ORIGIN_BR = 0x01,
-      TGA_ORIGIN_UL = 0x02,
-      TGA_ORIGIN_UR = 0x03
-
-    if (buffer.length < 19) console.error('THREE.TGALoader: Not enough data to contain header.')
-
-    var content = new Uint8Array(buffer),
-      offset = 0,
-      header = {
-        id_length: content[offset++],
-        colormap_type: content[offset++],
-        image_type: content[offset++],
-        colormap_index: content[offset++] | (content[offset++] << 8),
-        colormap_length: content[offset++] | (content[offset++] << 8),
-        colormap_size: content[offset++],
-        origin: [content[offset++] | (content[offset++] << 8), content[offset++] | (content[offset++] << 8)],
-        width: content[offset++] | (content[offset++] << 8),
-        height: content[offset++] | (content[offset++] << 8),
-        pixel_size: content[offset++],
-        flags: content[offset++]
-      }
-
-    // check tga if it is valid format
-
-    tgaCheckHeader(header)
-
-    if (header.id_length + offset > buffer.length) {
-      console.error('THREE.TGALoader: No data.')
-    }
-
-    // skip the needn't data
-
-    offset += header.id_length
-
-    // get targa information about RLE compression and palette
-
-    var use_rle = false,
-      use_pal = false,
-      use_grey = false
-
-    switch (header.image_type) {
-      case TGA_TYPE_RLE_INDEXED:
-        use_rle = true
-        use_pal = true
-        break
-
-      case TGA_TYPE_INDEXED:
-        use_pal = true
-        break
-
-      case TGA_TYPE_RLE_RGB:
-        use_rle = true
-        break
-
-      case TGA_TYPE_RGB:
-        break
-
-      case TGA_TYPE_RLE_GREY:
-        use_rle = true
-        use_grey = true
-        break
-
-      case TGA_TYPE_GREY:
-        use_grey = true
-        break
-    }
-
-    //
-
-    var useOffscreen = typeof OffscreenCanvas !== 'undefined'
-
-    var canvas = useOffscreen ? new OffscreenCanvas(header.width, header.height) : document.createElement('canvas')
-    canvas.width = header.width
-    canvas.height = header.height
-
-    var context = canvas.getContext('2d')
-    var imageData = context.createImageData(header.width, header.height)
-
-    var result = tgaParse(use_rle, use_pal, header, offset, content)
-    var rgbaData = getTgaRGBA(imageData.data, header.width, header.height, result.pixel_data, result.palettes)
-
-    context.putImageData(imageData, 0, 0)
-
-    return useOffscreen ? canvas.transferToImageBitmap() : canvas
-  },
-
-  setPath: function(value) {
-    this.path = value
-    return this
-  }
-}
-
-export default TGALoader

package/src/mixins/visible.js

@@ -1,185 +0,0 @@
-export default superclass => {
-  var A = class extends superclass {
-    constructor(model, canvasSize, visualizer) {
-      super()
-
-      this._model = model
-
-      this._visualizer = visualizer
-      this._canvasSize = canvasSize
-
-      this.name = this.model.id
-
-      this.createObject()
-
-      this.setPosition()
-      this.setRotation()
-    }
-
-    get model() {
-      return this._model
-    }
-
-    get type() {
-      return this.model.type || this._type
-    }
-    set type(type) {
-      this._type = type
-    }
-
-    get cx() {
-      if (!this._cx) {
-        var { left = 0, width = 0 } = this.model
-        var canvasSize = this._canvasSize
-
-        this._cx = left + width / 2 - canvasSize.width / 2
-      }
-      return this._cx
-    }
-
-    get cy() {
-      if (!this._cy) {
-        var { top = 0, height = 0 } = this.model
-        var canvasSize = this._canvasSize
-
-        this._cy = top + height / 2 - canvasSize.height / 2
-      }
-      return this._cy
-    }
-
-    get cz() {
-      if (!this._cz) {
-        var { zPos = 0, depth = 1 } = this.model
-
-        this._cz = zPos + depth / 2
-      }
-
-      return this._cz
-    }
-
-    dispose() {
-      this.children.slice().forEach(child => {
-        if (child.dispose) child.dispose()
-        if (child.geometry && child.geometry.dispose) child.geometry.dispose()
-        if (child.material && child.material.dispose) child.material.dispose()
-        if (child.texture && child.texture.dispose) child.texture.dispose()
-        this.remove(child)
-      })
-    }
-
-    onBeforeRender() {
-      super.onBeforeRender()
-    }
-
-async createObject() {}
-
-    setPosition() {
-      this.position.set(this.cx, this.cz, this.cy)
-    }
-
-    setRotation() {
-      var { rotationX = 0, rotationY = 0, rotation = 0 } = this.model
-
-      this.rotation.x = -rotationX
-      this.rotation.y = -rotation
-      this.rotation.z = -rotationY
-    }
-
-    onUserDataChanged() {
-      if (!this.userData) return
-
-      if (this.userData.hasOwnProperty('position')) {
-        if (!this._visualizer) return
-
-        this._setPosition(this._visualizer.transcoord2dTo3d(this.userData.position))
-      }
-
-      if (this.userData.hasOwnProperty('euler')) {
-        this._setEuler({
-          yaw: this.userData.euler.yaw,
-          pitch: this.userData.euler.pitch,
-          roll: this.userData.euler.roll
-        })
-      }
-
-      if (this.userData.hasOwnProperty('quaternion')) {
-        this._setQuaternion({
-          x: this.userData.quaternion.qx,
-          y: this.userData.quaternion.qy,
-          z: this.userData.quaternion.qz,
-          w: this.userData.quaternion.qw
-        })
-      }
-    }
-
-    _setPosition(location) {
-      var { x, y } = location
-
-      var index = this._visualizer.mixers.indexOf(this._mixer)
-      if (index >= 0) {
-        this._visualizer.mixers.splice(index, 1)
-      }
-
-      this._mixer = new THREE.AnimationMixer(this)
-      this._visualizer.mixers.push(this._mixer)
-
-      var positionKF = new THREE.VectorKeyframeTrack(
-        '.position',
-        [0, 1],
-        [this.position.x, this.position.y, this.position.z, x, this.position.y, y]
-      )
-      var clip = new THREE.AnimationClip('Move', 2, [positionKF])
-
-      // create a ClipAction and set it to play
-      var clipAction = this._mixer.clipAction(clip)
-      clipAction.clampWhenFinished = true
-      clipAction.loop = THREE.LoopOnce
-      clipAction.play()
-    }
-
-    _setQuaternion(quaternion) {
-      var { x, y, z, w } = quaternion
-
-      // var euler = new THREE.Euler();
-
-      // // var currentRotation = this.rotation;
-
-      // // console.log(currentRotation)
-
-      var q = new THREE.Quaternion()
-
-      q.set(x, y, z, w)
-
-      // euler.setFromQuaternion(q, 'ZYX');
-
-      // // euler.z -= Math.PI / 2;
-      // euler.z -= Math.PI / 2;
-
-      // var mat = new THREE.Matrix4();
-      // mat.makeRotationFromQuaternion(q);
-      // mat.transpose();
-
-      // q.setFromRotationMatrix(mat);
-
-      // this.setRotationFromEuler(euler);
-
-      this.setRotationFromQuaternion(q)
-      this.rotateOnAxis(new THREE.Vector3(1, 0, 0), -Math.PI)
-      this.rotateOnAxis(new THREE.Vector3(0, 1, 0), Math.PI)
-      this.rotateOnAxis(new THREE.Vector3(0, 0, 1), -Math.PI / 2)
-      // this.rotateOnAxis(new THREE.Vector3(0, 0, 1), -Math.PI);
-      // this.updateMatrix()
-    }
-
-    _setEuler(euler) {
-      var { yaw, pitch, roll } = euler
-      var e = new THREE.Euler()
-
-      e.set(yaw, pitch, roll, 'ZYX')
-
-      this.setRotationFromEuler(e)
-    }
-  }
-
-  return A
-}