@eturnity/eturnity_3d 6.48.4 → 6.48.5-EPDM-8599.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "6.48.4",
+  "version": "6.48.5-EPDM-8599.0",
   "main": "dist/main.js",
   "scripts": {
     "dev": "vue-cli-service serve --skip-plugins @vue/cli-plugin-eslint",
@@ -10,7 +10,7 @@
     "prettier": "prettier --write \"**/*.{js,vue}\""
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "6.48.3",
+    "@eturnity/eturnity_maths": "6.48.4-EPDM-8599.0",
     "core-js": "^2.6.12",
     "cors": "^2.8.5",
     "earcut": "^2.2.4",

package/src/helper/UpdateRoofObstacleRelations.js

@@ -1,6 +1,7 @@
 import {
   verticalProjectionOnPlane,
-  calculateArea
+  calculateArea,
+  isInsidePolygon
 } from '@eturnity/eturnity_maths'
 import { intersectOutlines } from '@eturnity/eturnity_maths'
 //this function just update the "roof" and "holes" properties of roofs and obstacles
@@ -41,19 +42,22 @@ export function UpdateRoofObstacleRelations(state, updateVersionEnable = true) {
     })
 
     let heightReference = 0
-    for (let roof of roofsWithObstacle) {
-      //updateObstacle z values
-      if (obstacle.layer == 'obstacle') {
-        obstacle.outline.forEach(
-          (p) =>
-            (p.z = verticalProjectionOnPlane(
-              p,
-              roof.normalVector,
-              roof.flatOutline[0]
-            ).z)
+    //updateObstacle z values
+    if (obstacle.layer == 'obstacle') {
+      obstacle.outline.forEach((p) => {
+        let roof = roofsWithObstacle.find((roof) =>
+          isInsidePolygon(p, roof.outline)
         )
-      }
-
+        if (roof) {
+          p.z = verticalProjectionOnPlane(
+            p,
+            roof.normalVector,
+            roof.flatOutline[0]
+          ).z
+        }
+      })
+    }
+    for (let roof of roofsWithObstacle) {
       heightReference = obstacle.outline.reduce((acc, cur) => {
         acc = Math.max(
           acc,

package/src/helper/materialMixin.js

@@ -37,6 +37,7 @@ export default {
       transparent: true,
       opacity: beamOpacity
     })
+
     this.material.node = new THREE.PointsMaterial({
       size: 0.05,
       sizeAttenuation: true,
@@ -48,7 +49,7 @@ export default {
     this.material.panel = {}
 
     for (let k = 0; k < defaultTextureUrls.length; k++) {
-      const texture = this.loader.load(
+      let texture = this.loader.load(
         defaultTextureUrls[k],
         function (texture) {}
       )
@@ -69,7 +70,39 @@ export default {
       opacity: 0.5
     })
 
-    this.material.moduleField = new THREE.MeshPhongMaterial({
+    this.material.highlight = new THREE.MeshPhongMaterial({
+      color: 0xffffff,
+      specular: 0x009900,
+      shininess: 0,
+      flatShading: true,
+      side: THREE.DoubleSide,
+      transparent: true,
+      opacity: 0.4,
+      alphaTest: 0.3
+    })
+    this.material.selected = new THREE.MeshPhongMaterial({
+      color: 0x5050ff,
+      specular: 0x009900,
+      shininess: 0,
+      flatShading: true,
+      side: THREE.DoubleSide,
+      transparent: true,
+      opacity: 0.5,
+      alphaTest: 0.3
+    })
+    this.material.hidden = new THREE.MeshBasicMaterial({
+      color: 0xffffff,
+      transparent: true,
+      alphaTest: 1,
+      opacity: 0
+    })
+    this.material.moduleField = new THREE.MeshBasicMaterial({
+      color: 0xe0e0ff,
+      side: THREE.DoubleSide,
+      transparent: true,
+      opacity: 0.3
+    })
+    this.material.moduleFieldWithPanelOveride = new THREE.MeshPhongMaterial({
       color: 0xfc9d03,
       specular: 0x000000,
       shininess: 0,

package/src/helper/render/clear.js

@@ -1,6 +1,7 @@
 export default {
   methods: {
     clearThreeObjects(obj) {
+      if(!obj){return}
       while (obj.children.length > 0) {
         this.clearThreeObjects(obj.children[0])
         obj.remove(obj.children[0])
@@ -40,7 +41,7 @@ export default {
       )
     },
     clearMesh(mesh) {
-      if (!mesh) {
+      if (!mesh || this.scene) {
         return
       }
       this.scene.remove(mesh)

package/src/helper/render/mergedGeometry.js

@@ -10,9 +10,8 @@ export default {
       geometries.forEach((geometry) => {
         const positions = geometry.attributes.position.array
         const normals = geometry.attributes.normal.array
-
-        mergedVertices.push(...positions)
-        mergedNormals.push(...normals)
+        mergedVertices.push(...positions.slice(0, 3 * geometry.drawRange.count))
+        mergedNormals.push(...normals.slice(0, 3 * geometry.drawRange.count))
 
         if (geometry.attributes.uv) {
           const uvs = geometry.attributes.uv.array

package/src/helper/render/moduleField.js

@@ -4,17 +4,19 @@ export default {
   methods: {
     renderModuleFields() {
       this.clearByType('moduleFieldsMeshes')
-
+      if (!this.areModuleFieldsVisible) {
+        return
+      }
       this.moduleFields.forEach((moduleFieldPolygon) => {
-        if (
-          !moduleFieldPolygon.data.number_of_panels_override &&
-          !this.areModuleFieldsVisible
-        )
-          return
         const geometry = getBufferModuleFieldGeometry(moduleFieldPolygon)
         if (geometry) {
+          let material
+          if(moduleFieldPolygon.data.number_of_panels_override){
+            material=this.material.moduleFieldWithPanelOveride
+          }else{
+            material=this.material.moduleField
+          }
           const mesh = new THREE.Mesh(geometry, this.material.moduleField)
-          geometry.dispose()
           mesh.matrixAutoUpdate = false
           mesh.userData.version = moduleFieldPolygon.version
           mesh.userData.type = 'moduleFieldsMeshes'

package/src/helper/render/obstacle.js

@@ -35,7 +35,8 @@ export default {
               roofPolygon
             )
             if (geometry && geometrySide) {
-              const mesh = new THREE.Mesh(geometry, this.material.roof)
+              const mesh = new THREE.Mesh(geometry, this.material.hidden)
+
               const meshSide = new THREE.Mesh(geometrySide, this.material.wall)
               // this.applyTextureOnMesh(this.material.roof, mesh)
 
@@ -56,6 +57,7 @@ export default {
               this.meshes.obstacleMeshes[
                 obstaclePolygon.id + '-' + roofPolygon.id + '_side'
               ] = meshSide
+              this.scene.add(mesh)
             }
             obstacleGeometries.push(
               this.meshes.obstacleMeshes[

package/src/helper/render/panel.js

@@ -57,6 +57,9 @@ export default {
       let panelSideGeometries = []
       let panelTopGeometries = {}
       this.panels.forEach((panelPolygon) => {
+        if (!panelPolygon.visible) {
+          return
+        }
         //definition of the material
         if (panelPolygon.moduleField.data.number_of_panels_override) {
           return

package/src/helper/render/roof.js

@@ -8,7 +8,7 @@ import {
   intersectOutlines,
   verticalProjectionOnPlane
 } from '@eturnity/eturnity_maths'
-import {debounce} from 'lodash'
+import { debounce } from 'lodash'
 export default {
   data() {
     return {
@@ -99,7 +99,6 @@ export default {
           mesh.userData.version = roofPolygon.version
           geometry = mesh.geometry
           geometry = this.updateRoofGeometry(geometry, roofPolygon)
-
           //in order to be able to render multiple material on it (background and image overlay)
           mesh.geometry = geometry
           mesh.updateMatrix()
@@ -109,13 +108,14 @@ export default {
           //create
           geometry = this.createRoofGeometry(roofPolygon)
           if (geometry) {
-            mesh = new THREE.Mesh(geometry, this.material.roof)
+            //material not used here.
+            mesh = new THREE.Mesh(geometry, this.material.hidden)
             mesh.userData.version = roofPolygon.version
             mesh.userData.type = 'roofMeshes'
             mesh.userData.meshId = roofPolygon.id
             mesh.userData.polygonId = roofPolygon.id
-            mesh.matrixAutoUpdate = false
             this.meshes.roofMeshes[roofPolygon.id] = mesh
+            this.scene.add(mesh)
           }
         }
         roofGeometries.push(this.meshes.roofMeshes[roofPolygon.id].geometry)
@@ -126,6 +126,7 @@ export default {
         roofGeometries,
         this.material.roof
       )
+      this.mergedRoofMesh.userData.type = 'mergedRoofMesh'
       this.applyTextureOnMesh(this.material.roof, this.mergedRoofMesh)
     },
     renderFlatRoofs() {
@@ -136,8 +137,6 @@ export default {
         if (geometry) {
           const material = this.material.curvedRoof
           const mesh = new THREE.Mesh(geometry, material)
-          geometry.dispose()
-          geometry = null
           mesh.itemData = roofPolygon
           mesh.frustumCulled = false
           this.scene.add(mesh)

package/src/helper/render/tile.js

@@ -28,6 +28,9 @@ export default {
       this.renderTiles()
     }, 1000),
     async renderTiles() {
+      if (!this.scene) {
+        return
+      }
       if (
         !this.selectedMapLayer ||
         ['googleLayerRoadmap', 'googleLayer', 'googleLayerTerrain'].includes(
@@ -62,6 +65,7 @@ export default {
         this.scene.remove(this.googleBackgroundMap)
         this.clearThreeObjects(this.googleBackgroundMap)
       }
+
       let zoomLvl = this.provider.maxZoom
 
       const latitude = this.layoutSettings.layout_latitude

package/src/helper/renderMixin.js

@@ -173,6 +173,11 @@ export default {
               arg: []
             })
           } else if (params.layer == 'obstacle') {
+            methodList.push({
+              name: 'renderBase',
+              method: this.renderBase,
+              arg: []
+            })
             methodList.push({
               name: 'renderRoofs',
               method: this.renderRoofs,
@@ -398,13 +403,16 @@ export default {
       this.tweenCamera = null
     }
     this.clearThreeObjects(this.scene)
+
     if (this.three_map) {
       this.three_map.clear()
       this.clearThreeObjects(this.three_map)
     }
     this.renderer.clear()
     this.renderer.dispose()
-    this.orbitControl.dispose()
+    if (this.orbitControl && this.orbitControl.dispose) {
+      this.orbitControl.dispose()
+    }
 
     this.renderer = null
     this.scene = null

package/src/helper/threeMixin.js

@@ -22,7 +22,10 @@ export default {
 
       if (this.selectedMapLayer === null) {
         for (var i in this.layers) {
-          if (this.globalProjectProperties && this.layers[i].key === this.globalProjectProperties.map_type) {
+          if (
+            this.globalProjectProperties &&
+            this.layers[i].key === this.globalProjectProperties.map_type
+          ) {
             this.setSelectedMapLayer(this.layers[i])
           }
         }
@@ -131,21 +134,26 @@ export default {
       this.resizeCanvasToDisplaySize()
     },
     resizeCanvasToDisplaySize() {
+      console.log("resizeCanvasToDisplaySize")
       const canvas = this.renderer.domElement
       // look up the size the canvas is being displayed
       const width = canvas.clientWidth
       const height = canvas.clientHeight
-
       // adjust displayBuffer size to match
       if (canvas.width !== width || canvas.height !== height) {
         // you must pass false here or three.js sadly fights the browser
+
         this.renderer.setSize(width, height, false)
         this.renderer.setViewport(0, 0, width, height)
-
+        if (this.composer) {
+          //this.composer.setSize(width, height, false)
+          this.composer.setPixelRatio(Math.min(window.devicePixelRatio, 2))
+          if (this.composer.setViewport) {
+            this.composer.setViewport(0, 0, width, height)
+          }
+        }
         this.camera.aspect = width / height
         this.camera.updateProjectionMatrix()
-
-        // update any render target sizes here
       }
     }
   }

package/src/store/nodesEdgesCreation.js

@@ -1,9 +1,9 @@
 import { Point, Line } from '@eturnity/eturnity_maths'
 import { mmTolerance } from '../config'
 import {
-  isSamePoint3D,
+  isAlmostSamePoint3D,
   isAlmostSameSegment2D,
-  isSameSegment3D,
+  isAlmostSameSegment3D,
   isAlmostSamePoint2D
 } from '@eturnity/eturnity_maths'
 
@@ -83,7 +83,9 @@ export function generateNodes3D(polygons) {
       const outline = polygon.outline
       outline.forEach((point, i) => {
         //check if nodes2D already exist
-        let node3D = nodes3D.find((node) => isSamePoint3D(node, point))
+        let node3D = nodes3D.find((node) =>
+          isAlmostSamePoint3D(node, point, mmTolerance)
+        )
         if (!node3D) {
           node3D = new Point(point.x, point.y, point.z, polygon.layer)
           node3D.belongsTo = []
@@ -178,8 +180,11 @@ export function generateEdges3D(polygons) {
         //check if edge2D already exist
         const nextPoint = outline[(i + 1) % outline.length]
         let edge3D = edges3D.find((edge) => {
-          isSameSegment3D([point, nextPoint], edge.outline) &&
-            edge.layer == polygon.layer
+          isAlmostSameSegment3D(
+            [point, nextPoint],
+            edge.outline,
+            mmTolerance
+          ) && edge.layer == polygon.layer
         })
         if (!edge3D) {
           //create an edge at this position