@eturnity/eturnity_3d 6.29.1 → 6.29.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "6.29.1",
+  "version": "6.29.2",
   "main": "dist/main.js",
   "scripts": {
     "dev": "vue-cli-service serve --skip-plugins @vue/cli-plugin-eslint",

package/src/helper/renderMixin.js

@@ -1,10 +1,10 @@
-import {mapState, mapGetters } from 'vuex'
+import { mapState, mapGetters } from 'vuex'
 import renderMixin from './render'
 import cameraMixin from './cameraMixin'
 import * as THREE from 'three'
 
 export default {
-  mixins:[renderMixin,cameraMixin],
+  mixins: [renderMixin, cameraMixin],
   data() {
     return {
       meshes: {
@@ -21,7 +21,7 @@ export default {
       lastTic: new Date().getTime() * 1e4,
       //lastTic:(new Date()).getTime()
       lastGeometryEventIdDone: -1,
-      backgroundImagesizeInMm:null,
+      backgroundImagesizeInMm: null
     }
   },
   created() {
@@ -36,7 +36,7 @@ export default {
       roofMarginMeshes: {},
       moduleFieldsMeshes: {}
     }
-    if(this.wallColor){
+    if (this.wallColor) {
       let wallColor = new THREE.Color(this.wallColor)
       this.material.wall.color.set(wallColor)
     }
@@ -44,7 +44,8 @@ export default {
 
   computed: {
     ...mapState({
-      moduleTextureVersionId: (state) => state.threeDModule.moduleTextureVersionId,
+      moduleTextureVersionId: (state) =>
+        state.threeDModule.moduleTextureVersionId,
       wallColor: (state) => state.threeDModule.wallColor,
       selectedMapLayer: (state) => state.threeDModule.selectedMapLayer,
       pvDataMemo: (state) => state.threeDModule.pvDataMemo
@@ -53,13 +54,13 @@ export default {
       selectedTool: 'getSelectedTool',
       roofs: 'getRoofs',
       lastGeometryEventId: 'getLastGeometryEventId',
-      roofsBounds:'getRoofsBounds',
+      roofsBounds: 'getRoofsBounds',
       geometryEvents: 'getGeometryEvents'
     }),
-    layerKey(){
-      if(this.selectedMapLayer){
+    layerKey() {
+      if (this.selectedMapLayer) {
         return this.selectedMapLayer.key
-      }else{
+      } else {
         return null
       }
     },
@@ -103,8 +104,7 @@ export default {
           this.renderMethods(methodList)
         }
       }
-      
-      
+
       this.lastGeometryEventIdDone = this.lastGeometryEventId
     },
     renderingMethodsByEvent(geometryEvent) {
@@ -209,13 +209,13 @@ export default {
             arg: []
           })
           break
-          case 'clearPanelFromChangingRoofs':
-            methodList.push({
-              name: 'clearPanelsFromChangingRoofs',
-              method: this.clearPanelsFromChangingRoofs,
-              arg: [params.roofIds]
-            })
-            break
+        case 'clearPanelFromChangingRoofs':
+          methodList.push({
+            name: 'clearPanelsFromChangingRoofs',
+            method: this.clearPanelsFromChangingRoofs,
+            arg: [params.roofIds]
+          })
+          break
       }
       return methodList
     },
@@ -240,183 +240,33 @@ export default {
       this.renderFlatRoofs()
     },
 
-    applyTextureOnRoofs(){
-      this.roofs.forEach(roof=>{
+    applyTextureOnRoofs() {
+      this.roofs.forEach((roof) => {
         //roofs
-        let mesh=this.meshes.roofMeshes[roof.id]
-        mesh.material=this.material.roof
-        if(this.material.roof && this.material.roof.project){
+        let mesh = this.meshes.roofMeshes[roof.id]
+        mesh.material = this.material.roof
+        if (this.material.roof && this.material.roof.project) {
           this.material.roof.project(mesh)
         }
         //obstacle on roof
-        roof.holes.filter(p=>p.layer=="obstacle").forEach(obstacle=>{
-          let meshObstacle=this.meshes.obstacleMeshes[obstacle.id + '-' + roof.id + '_top']
-          meshObstacle.material=this.material.roof
-          if(this.material.roof && this.material.roof.project) this.material.roof.project(meshObstacle)
-        })
+        roof.holes
+          .filter((p) => p.layer == 'obstacle')
+          .forEach((obstacle) => {
+            let meshObstacle =
+              this.meshes.obstacleMeshes[obstacle.id + '-' + roof.id + '_top']
+            meshObstacle.material = this.material.roof
+            if (this.material.roof && this.material.roof.project)
+              this.material.roof.project(meshObstacle)
+          })
       })
     },
-   
-    async updateProjectionMaterial(){
+
+    async updateProjectionMaterial() {
       await this.loadProjectionMaterial()
       this.applyTextureOnRoofs()
       this.renderBackground()
     },
-<<<<<<< HEAD
-    async loadProjectionMaterial() {
-      const _this=this
-      if(!this.layoutSettings.base64_image_url) 
-      {
-        this.loader.load(require("../assets/images/white_tile.png"),(texture)=>{
-          let projectionMaterial = new ProjectedMaterial({
-            camera: _this.cameraprojection,
-            texture: texture
-          })
-        this.material.roof = projectionMaterial
-        })
-        return
-      }
-      let projectedMaterialLoaded= await new Promise((resolve,reject) => {
-        this.loader.load(this.layoutSettings.base64_image_url,(texture)=>{
-          let backgroundImageZoomLvl=_this.layoutSettings.map_zoom
-          let backgroundImageCenter={
-            lat:_this.layoutSettings.layout_latitude,
-            lng:_this.layoutSettings.layout_longitude
-          }
-          if(_this.layoutSettings.background_map_settings){
-            backgroundImageZoomLvl=_this.layoutSettings.background_map_settings.zoom_lvl
-            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 averageLat=(_this.layoutSettings.layout_latitude+_this.layoutSettings.background_map_settings.lat)/2
-                // let deltaLat=_this.layoutSettings.background_map_settings.lat-_this.layoutSettings.layout_latitude
-                // let deltaLng=_this.layoutSettings.background_map_settings.lng-_this.layoutSettings.layout_longitude
-                // let {x:x_mm,y:y_mm}=deltaLatLngToDistance(deltaLat,deltaLng,averageLat)
-                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 * 16
-            _this.cameraprojection.updateProjectionMatrix()
-          }
-          
-          let projectionMaterial = new ProjectedMaterial({
-            camera: _this.cameraprojection,
-            texture: texture
-          })
-          resolve(projectionMaterial)
-        })
-      })
-      this.material.roof =projectedMaterialLoaded
-    },
-    setCameraGlobalPosition() {
-      if(this.roofs.length==0)return
-      let bounds=this.roofsBounds
-      let targetVector={x:(bounds.xMax+bounds.xMin)/2000,y:(bounds.yMax+bounds.yMin)/2000,z:0}
-      let objectRadius_m=Math.max((bounds.xMax-bounds.xMin)/2000,(bounds.yMax-bounds.yMin)/2000)
-      let distance =
-          5 + objectRadius_m / Math.sin(((this.camera.fov / 2) * Math.PI) / 180)
-      let cameraMoveVector = { x: 0, y: 0, z: distance }
-      const positionVector = addVector(targetVector, cameraMoveVector)
-      const position = [
-        positionVector.x,
-        positionVector.y - distance,
-        positionVector.z
-      ]
-      let target=[
-        targetVector.x,
-        targetVector.y,
-        targetVector.z
-      ]
-     
-      this.setTweenTo(position,target)
-    },
-    setCameraOrthogonalTo(polygon) {
-      if (polygon) {
-        let polygonRef = polygon
-        const targetVector = polygonRef.meanPoint
-        const target = [
-          targetVector.x / 1000,
-          targetVector.y / 1000,
-          targetVector.z / 1000
-        ]
-        const positionVector = addVector(
-          polygonRef.meanPoint,
-          multiplyVector(45000, polygonRef.normalVector)
-        )
-        const position = [
-          positionVector.x / 1000,
-          positionVector.y / 1000 - 1,
-          positionVector.z / 1000
-        ]
-        this.setTweenTo(position,target)
-      }
-    },
-    setCameraSideTo(polygon) {
-      if (polygon) {
-        let polygonRef = polygon
-        const targetVector = polygonRef.meanPoint
-        const target = [
-          targetVector.x / 1000,
-          targetVector.y / 1000,
-          targetVector.z / 1000
-        ]
-        let sideVector={x:-Math.cos((polygonRef.direction+45)*Math.PI/180),y:Math.sin((polygonRef.direction+45)*Math.PI/180),z: 0}
-        const positionVector = addVector(
-          polygonRef.meanPoint,
-          multiplyVector(45000, sideVector)
-        )
-        const position = [
-          positionVector.x / 1000,
-          positionVector.y / 1000,
-          positionVector.z / 1000 +5
-        ]
-        this.setTweenTo(position,target)
-      }
-    },
-    setTweenTo(position,target){
-      if (this.orbitControl) {
-        this.tweenOrbit = new TWEEN.Tween(this.orbitControl.target)
-          .to({ x: target[0], y: target[1], z: target[2] }, 2000)
-          .easing(TWEEN.Easing.Sinusoidal.Out)
-          .onUpdate(() => {
-            if(this.orbitControl){
-              this.orbitControl.update()
-            } 
-          })
-          .start()
-      }
-      if (this.camera) {
-        this.tweenCamera = new TWEEN.Tween(this.camera.position)
-          .to({ x: position[0], y: position[1], z: position[2] }, 2000)
-          .easing(TWEEN.Easing.Sinusoidal.Out)
-          .onUpdate(() => {
-            if(this.orbitControl){
-              this.orbitControl.update()
-            } 
-          })
-          .start()
-      }
-    },
-=======
-  
->>>>>>> origin/EPDM-7663
     getCanvasOffset() {
       if (!this.$refs.canvas3DContainer) return { top: 0, left: 0 }
       var box = this.$refs.canvas3DContainer.getBoundingClientRect()
@@ -464,7 +314,7 @@ export default {
         // update any render target sizes here
       }
       canvas = null
-    },
+    }
   },
   watch: {
     wallColor(color) {
@@ -476,8 +326,8 @@ export default {
         this.loadNewTexture()
       }
     },
-    'material.panel':{
-      handler(){
+    'material.panel': {
+      handler() {
         this.renderPanels()
       }
     },
@@ -495,7 +345,7 @@ export default {
       this.tweenCamera = null
     }
     this.clearThreeObjects(this.scene)
-    if(this.three_map){
+    if (this.three_map) {
       this.three_map.clear()
       this.clearThreeObjects(this.three_map)
     }