@eturnity/eturnity_3d 6.34.6 → 6.34.7

package/src/helper/MapView.js

@@ -1,221 +0,0 @@
-import { Mesh, MeshBasicMaterial } from 'three'
-import { MapNode, LODRaycast, MapPlaneNode } from 'geo-three'
-/**
- * Map viewer is used to read and display map tiles from a server.
- *
- * It was designed to work with a OpenMapTiles but can also be used with another map tiles.
- *
- * The map is drawn in plane map nodes using a quad tree that is subdivided as necessary to guaratee good map quality.
- */
-export class MapView extends Mesh {
-  /**
-   * Planar map projection.
-   */
-  PLANAR = 200
-
-  mapModes = new Map([[MapView.PLANAR, MapPlaneNode]])
-
-  /**
-   * LOD control object used to defined how tiles are loaded in and out of memory.
-   */
-  lod = null
-
-  /**
-   * Map tile color layer provider.
-   */
-  provider = null
-
-  /**
-   * Map height (terrain elevation) layer provider.
-   *
-   * Only used for HEIGHT, HEIGHT_SHADER and MARTINI map modes.
-   */
-  heightProvider = null
-
-  /**
-   * Define the type of map node in use, defined how the map is presented.
-   *
-   * Should only be set on creation.
-   */
-  root = null
-
-  /**
-   * Indicate if the nodes should cache its children when it is simplified. Nodes that are no longer in use should be kept in memory.
-   *
-   * Usefull for fast moving scenarios to prevent reparsing data in fast moving scenes.
-   *
-   * Should only be used if the child generation process is time consuming. Should be kept off unless required.
-   */
-  cacheTiles = false
-
-  /**
-   * Constructor for the map view objects.
-   *
-   * @param root - Map view node modes can be SPHERICAL, HEIGHT or PLANAR. PLANAR is used by default. Can also be a custom MapNode instance.
-   * @param provider - Map color tile provider by default a OSM maps provider is used if none specified.
-   * @param heightProvider - Map height tile provider, by default no height provider is used.
-   */
-  constructor(
-    root = MapView.PLANAR,
-    provider = new OpenStreetMapsProvider(),
-    heightProvider = null
-  ) {
-    super(undefined, new MeshBasicMaterial({ transparent: true, opacity: 0.0 }))
-    this.lod = new LODRaycast()
-    this.provider = provider
-    this.heightProvider = heightProvider
-    this.setRoot(root)
-    this.preSubdivide()
-  }
-
-  /**
-   * Ajust node configuration depending on the camera distance.
-   *
-   * Called everytime automatically before render by the renderer.
-   */
-  onBeforeRender = (renderer, scene, camera) => {
-    this.lod.updateLOD(this, camera, renderer, scene)
-  }
-
-  /**
-   * Set the root of the map view.
-   *
-   * Is set by the constructor by default, can be changed in runtime.
-   *
-   * @param root - Map node to be used as root.
-   */
-  setRoot(root) {
-    if (typeof root === 'number') {
-      const rootConstructor = MapPlaneNode //MapView.mapModes.get(root);
-      // @ts-ignore
-      root = new rootConstructor(null, this)
-    }
-
-    // Remove old root
-    if (!!this.root) {
-      this.remove(this.root)
-      this.root = null
-    }
-
-    // @ts-ignore
-    this.root = root
-
-    // Initialize root node
-    if (!!this.root) {
-      // @ts-ignore
-      this.geometry = this.root.constructor.baseGeometry
-      // // @ts-ignore
-      this.scale.copy(this.root.constructor.baseScale)
-
-      this.root.mapView = this
-      this.add(this.root)
-      this.root.initialize()
-    }
-  }
-
-  /**
-   * Pre-subdivide map tree to create nodes of levels not available in the provider.
-   *
-   * Checks for the minimum zoom level in the providers attached to the map view.
-   */
-  preSubdivide() {
-    const minZoom = this.provider.minZoom
-    const maxZoom = this.provider.maxZoom
-    function subdivide(node, depth) {
-      if (depth <= 0) {
-        return
-      }
-
-      node.subdivide()
-
-      for (let i = 0; i < node.children.length; i++) {
-        if (node.children[i] instanceof MapNode) {
-          const child = node.children[i]
-          subdivide(child, depth - 1)
-        }
-      }
-    }
-
-    if (minZoom > 0) {
-      subdivide(this.root, minZoom)
-    }
-  }
-
-  /**
-   * Change the map provider of this map view.
-   *
-   * Will discard all the tiles already loaded using the old provider.
-   */
-  setProvider(provider) {
-    if (provider !== this.provider) {
-      this.provider = provider
-      this.clear()
-    }
-  }
-
-  /**
-   * Change the map height provider of this map view.
-   *
-   * Will discard all the tiles already loaded using the old provider.
-   */
-  setHeightProvider(heightProvider) {
-    if (heightProvider !== this.heightProvider) {
-      this.heightProvider = heightProvider
-      this.clear()
-    }
-  }
-
-  /**
-   * Clears all tiles from memory and reloads data. Used when changing the provider.
-   *
-   * Should be called manually if any changed to the provider are made without setting the provider.
-   */
-  clear() {
-    this.traverse(function (children) {
-      // @ts-ignore
-      if (children.childrenCache) {
-        // @ts-ignore
-        children.childrenCache = null
-      }
-
-      // @ts-ignore
-      if (children.initialize) {
-        // @ts-ignore
-        children.initialize()
-      }
-    })
-
-    return this
-  }
-
-  /**
-   * Get the minimum zoom level available in the providers attached to the map view.
-   *
-   * @returns Minimum zoom level available.
-   */
-  minZoom() {
-    return 15
-    return Math.max(this.provider.minZoom, -Infinity)
-  }
-
-  /**
-   * Get the maximum zoom level available in the providers attached to the map view.
-   *
-   * @returns Maximum zoom level available.
-   */
-  maxZoom() {
-    return 18
-    return Math.min(this.provider.maxZoom, Infinity)
-  }
-
-  /**
-   * Get map meta data from server if supported.
-   */
-  getMetaData() {
-    this.provider.getMetaData()
-  }
-
-  raycast(raycaster, intersects) {
-    return false
-  }
-}

package/src/helper/materials.js

@@ -1,77 +0,0 @@
-import * as THREE from 'three'
-import {
-  beamColor,
-  beamOpacity,
-  node3DColor,
-  node3dOpacity,
-  defaultTextureUrls
-} from '../config'
-const material = []
-
-material.wall = new THREE.MeshLambertMaterial({
-  color: 0xdddddd,
-  side: THREE.DoubleSide
-})
-
-// TODO get Canvas image from TwoD
-material.obstacle = new THREE.MeshPhongMaterial({
-  color: 0xff0000,
-  side: THREE.DoubleSide
-})
-
-material.edge = new THREE.MeshPhongMaterial({
-  color: beamColor,
-  transparent: true,
-  opacity: beamOpacity
-})
-material.node = new THREE.PointsMaterial({
-  size: 0.05,
-  sizeAttenuation: true,
-  color: node3DColor,
-  opacity: node3dOpacity,
-  transparent: true
-})
-const loader = new THREE.TextureLoader()
-// loader.crossOrigin = 'anonymous'
-// texture.minFilter = THREE.LinearFilter
-material.panel = {}
-
-for (let k = 0; k < defaultTextureUrls.length; k++) {
-  let texture = loader.load(defaultTextureUrls[k], function (texture) {})
-  material.panel['default_' + k] = new THREE.MeshBasicMaterial({
-    map: texture,
-    side: THREE.DoubleSide,
-    transparent: true
-  })
-}
-
-material.flatRoof = new THREE.MeshPhongMaterial({
-  color: 0x00ff00,
-  specular: 0x009900,
-  shininess: 0,
-  flatShading: true,
-  side: THREE.DoubleSide,
-  transparent: true,
-  opacity: 0.5
-})
-
-material.moduleField = new THREE.MeshPhongMaterial({
-  color: 0xfc9d03,
-  specular: 0x000000,
-  shininess: 0,
-  flatShading: true,
-  side: THREE.DoubleSide,
-  transparent: true,
-  opacity: 0.6
-})
-material.curvedRoof = new THREE.MeshPhongMaterial({
-  color: 0xffff00,
-  specular: 0x009900,
-  shininess: 0,
-  flatShading: true,
-  side: THREE.DoubleSide,
-  transparent: true,
-  opacity: 0.5
-})
-
-export { material }

package/src/helper/render/mapProjection.js

@@ -1,100 +0,0 @@
-import * as THREE from 'three'
-import ProjectedMaterial from 'three-projected-material'
-
-export default {
-  data() {
-    return {
-      mapProjectionTexture: null,
-      mapProjectionMaterial: null
-    }
-  },
-  methods: {
-    async changeMapProjection() {
-      if (this.mapProjectionMaterial) {
-        this.mapProjectionMaterial.dispose()
-        this.mapProjectionMaterial = null
-      }
-      await this.updateProjectionMaterials()
-    },
-    async getMapProjectionMaterial() {
-      if (!this.layoutSettings.base64_image_url) {
-        return null
-      } else {
-        if (!this.mapProjectionMaterial) {
-          this.mapProjectionMaterial = await this.newMapProjectionMaterial()
-        } else {
-          this.setMapProjectionCameraPosition()
-        }
-      }
-      return this.mapProjectionMaterial
-    },
-
-    async newMapProjectionMaterial() {
-      return new Promise((resolve, reject) => {
-        this.loader.load(this.layoutSettings.base64_image_url, (texture) => {
-          this.mapProjectionTexture = texture
-          this.setMapProjectionCameraPosition()
-          let mapProjectionMaterial = new ProjectedMaterial({
-            camera: this.cameraProjection,
-            texture: texture,
-            transparent: true,
-            side: THREE.DoubleSide
-          })
-          mapProjectionMaterial.userData = {}
-          mapProjectionMaterial.userData.type = 'mapProjectionMaterial'
-          mapProjectionMaterial.userData.priority = 1
-          mapProjectionMaterial.userData.url =
-            this.layoutSettings.base64_image_url
-          resolve(mapProjectionMaterial)
-        })
-      })
-    },
-    setMapProjectionCameraPosition() {
-      let backgroundImageCenter = {
-        lat: this.layoutSettings.layout_latitude,
-        lng: this.layoutSettings.layout_longitude
-      }
-      if (this.layoutSettings.background_map_settings) {
-        backgroundImageCenter = {
-          lat: this.layoutSettings.background_map_settings.lat,
-          lng: this.layoutSettings.background_map_settings.lng
-        }
-      }
-      this.backgroundImagesizeInMm =
-        this.layoutSettings.background_map_settings.sizeInMm
-      if (this.backgroundImagesizeInMm) {
-        this.cameraProjection.aspect =
-          this.backgroundImagesizeInMm.width /
-          this.backgroundImagesizeInMm.height
-        let projectionAltitude =
-          this.backgroundImagesizeInMm.height /
-          (2 * Math.tan((this.cameraProjection.fov * Math.PI) / 360))
-
-        //set projection camera over background_map_center
-        let cameraProjectionPosition = {
-          x: 0,
-          y: 0,
-          z: projectionAltitude / 1000
-        }
-        if (
-          this.layoutSettings.background_map_settings &&
-          this.layoutSettings.background_map_settings.positionInMm
-        ) {
-          let positionInMm =
-            this.layoutSettings.background_map_settings.positionInMm
-          cameraProjectionPosition.x = positionInMm.x / 1000
-          cameraProjectionPosition.y = positionInMm.y / 1000
-        }
-
-        this.cameraProjection.position.set(
-          cameraProjectionPosition.x,
-          cameraProjectionPosition.y,
-          projectionAltitude / 1000
-        )
-        this.cameraProjection.far = projectionAltitude * 1.5
-        this.cameraProjection.near = projectionAltitude * 0.5
-        this.cameraProjection.updateProjectionMatrix()
-      }
-    }
-  }
-}