@eturnity/eturnity_3d 6.34.0 → 6.34.1

package/src/helper/render/margin.js

@@ -1,22 +1,43 @@
 import * as THREE from 'three'
-import {
-  colorArrayBase,
-} from '../../config'
-import {
-  getBufferRoofMarginGeometry
-} from './geometryHandler'
+import { colorArrayBase } from '../../config'
+import { getBufferRoofMarginGeometry } from './geometryHandler'
 export default {
-    methods:{
-      renderRoofsMargin() {
-        this.clearByType('roofMarginMeshes')
-  
-        if (this.selectedTool == 'selectMargin') {
-          this.roofs.forEach((roofPolygon) => {
-            const geometries = getBufferRoofMarginGeometry(roofPolygon)
-  
+  methods: {
+    renderRoofsMargin() {
+      this.clearByType('roofMarginMeshes')
+
+      if (this.selectedTool == 'selectMargin') {
+        this.roofs.forEach((roofPolygon) => {
+          const geometries = getBufferRoofMarginGeometry(roofPolygon)
+
+          geometries.forEach((geometry, index) => {
+            if (geometry) {
+              const marginColor = roofPolygon.margins.isSameMargin
+                ? colorArrayBase[0]
+                : colorArrayBase[index % colorArrayBase.length]
+              let material = new THREE.MeshPhongMaterial({
+                color: marginColor,
+                specular: 0x009900,
+                shininess: 0,
+                flatShading: true,
+                side: THREE.DoubleSide,
+                transparent: true,
+                opacity: 0.8
+              })
+              const mesh = new THREE.Mesh(geometry, material)
+              geometry.dispose()
+              this.scene.add(mesh)
+              this.meshes.roofMarginMeshes[roofPolygon.id + '_' + index] = mesh
+            }
+          })
+          roofPolygon.holes.forEach((obstaclePolygon) => {
+            const geometries = getBufferRoofMarginGeometry(
+              obstaclePolygon,
+              roofPolygon
+            )
             geometries.forEach((geometry, index) => {
               if (geometry) {
-                const marginColor = roofPolygon.margins.isSameMargin
+                const marginColor = obstaclePolygon.margins.isSameMargin
                   ? colorArrayBase[0]
                   : colorArrayBase[index % colorArrayBase.length]
                 let material = new THREE.MeshPhongMaterial({
@@ -30,43 +51,18 @@ export default {
                 })
                 const mesh = new THREE.Mesh(geometry, material)
                 geometry.dispose()
+                geometry = null
+                material.dispose()
+                material = null
                 this.scene.add(mesh)
-                this.meshes.roofMarginMeshes[roofPolygon.id + '_' + index] = mesh
+                this.meshes.roofMarginMeshes[
+                  obstaclePolygon.id + '_' + roofPolygon.id + '_' + index
+                ] = mesh
               }
             })
-            roofPolygon.holes.forEach((obstaclePolygon) => {
-              const geometries = getBufferRoofMarginGeometry(
-                obstaclePolygon,
-                roofPolygon
-              )
-              geometries.forEach((geometry, index) => {
-                if (geometry) {
-                  const marginColor = obstaclePolygon.margins.isSameMargin
-                    ? colorArrayBase[0]
-                    : colorArrayBase[index % colorArrayBase.length]
-                  let material = new THREE.MeshPhongMaterial({
-                    color: marginColor,
-                    specular: 0x009900,
-                    shininess: 0,
-                    flatShading: true,
-                    side: THREE.DoubleSide,
-                    transparent: true,
-                    opacity: 0.8
-                  })
-                  const mesh = new THREE.Mesh(geometry, material)
-                  geometry.dispose()
-                  geometry = null
-                  material.dispose()
-                  material = null
-                  this.scene.add(mesh)
-                  this.meshes.roofMarginMeshes[
-                    obstaclePolygon.id + '_' + roofPolygon.id + '_' + index
-                  ] = mesh
-                }
-              })
-            })
           })
-        }
-      },
+        })
+      }
     }
-}
+  }
+}

package/src/helper/render/moduleField.js

@@ -1,27 +1,29 @@
 import * as THREE from 'three'
-import {
-  getBufferModuleFieldGeometry,
-} from './geometryHandler'
+import { getBufferModuleFieldGeometry } from './geometryHandler'
 export default {
-    methods:{
-      renderModuleFields() {
-        this.clearByType('moduleFieldsMeshes')
-  
-        this.moduleFields.forEach((moduleFieldPolygon) => {
-          if(!moduleFieldPolygon.data.number_of_panels_override && !this.areModuleFieldsVisible )return
-          const geometry = getBufferModuleFieldGeometry(moduleFieldPolygon)
-          if (geometry) {
-            const mesh = new THREE.Mesh(geometry, this.material.moduleField)
-            geometry.dispose()
-            mesh.matrixAutoUpdate = false
-            mesh.userData.version = moduleFieldPolygon.version
-            mesh.userData.type = 'moduleFieldsMeshes'
-            mesh.userData.meshId = moduleFieldPolygon.id
-            mesh.userData.polygonId = moduleFieldPolygon.id
-            this.scene.add(mesh)
-            this.meshes.moduleFieldsMeshes[moduleFieldPolygon.id] = mesh
-          }
-        })
-      },
+  methods: {
+    renderModuleFields() {
+      this.clearByType('moduleFieldsMeshes')
+
+      this.moduleFields.forEach((moduleFieldPolygon) => {
+        if (
+          !moduleFieldPolygon.data.number_of_panels_override &&
+          !this.areModuleFieldsVisible
+        )
+          return
+        const geometry = getBufferModuleFieldGeometry(moduleFieldPolygon)
+        if (geometry) {
+          const mesh = new THREE.Mesh(geometry, this.material.moduleField)
+          geometry.dispose()
+          mesh.matrixAutoUpdate = false
+          mesh.userData.version = moduleFieldPolygon.version
+          mesh.userData.type = 'moduleFieldsMeshes'
+          mesh.userData.meshId = moduleFieldPolygon.id
+          mesh.userData.polygonId = moduleFieldPolygon.id
+          this.scene.add(mesh)
+          this.meshes.moduleFieldsMeshes[moduleFieldPolygon.id] = mesh
+        }
+      })
     }
-}
+  }
+}

package/src/helper/render/node.js

@@ -1,47 +1,47 @@
 import * as THREE from 'three'
 
 export default {
-    methods:{
-        renderNodes() {
-            let geometry
-            if (this.meshes.nodeMeshes) {
-              geometry = this.meshes.nodeMeshes.geometry
-              geometry.attributes.position.needsUpdate = true
-            } else {
-              geometry = new THREE.BufferGeometry()
-            }
-            // let geometry = new THREE.SphereGeometry(node3DRadius, 4, 4)
-            const vertices = []
-            this.nodes
-              .filter((node) => node.layer == 'roof')
-              .forEach((node) => {
-                vertices.push(node.x / 1000, node.y / 1000, node.z / 1000)
-              })
-      
-            if (
-              geometry.attributes.position &&
-              geometry.attributes.position.array.length <= vertices.length
-            ) {
-              let positions = geometry.attributes.position.array
-              for (let k in vertices) {
-                positions[k] = vertices[k]
-              }
-              geometry.setDrawRange(0, vertices.length / 3)
-            } else {
-              geometry.setAttribute(
-                'position',
-                new THREE.Float32BufferAttribute(vertices, 3)
-              )
-            }
-            let material = this.material.node
-            const nodeMeshes = new THREE.Points(geometry, material)
-            nodeMeshes.userData.version = 0
-            nodeMeshes.userData.type = 'nodeMeshes'
-            nodeMeshes.userData.meshId = null
-            nodeMeshes.userData.polygonId = null
-            nodeMeshes.matrixAutoUpdate = false
-            this.meshes.nodeMeshes = nodeMeshes
-            this.scene.add(nodeMeshes)
-          },
+  methods: {
+    renderNodes() {
+      let geometry
+      if (this.meshes.nodeMeshes) {
+        geometry = this.meshes.nodeMeshes.geometry
+        geometry.attributes.position.needsUpdate = true
+      } else {
+        geometry = new THREE.BufferGeometry()
+      }
+      // let geometry = new THREE.SphereGeometry(node3DRadius, 4, 4)
+      const vertices = []
+      this.nodes
+        .filter((node) => node.layer == 'roof')
+        .forEach((node) => {
+          vertices.push(node.x / 1000, node.y / 1000, node.z / 1000)
+        })
+
+      if (
+        geometry.attributes.position &&
+        geometry.attributes.position.array.length <= vertices.length
+      ) {
+        let positions = geometry.attributes.position.array
+        for (let k in vertices) {
+          positions[k] = vertices[k]
+        }
+        geometry.setDrawRange(0, vertices.length / 3)
+      } else {
+        geometry.setAttribute(
+          'position',
+          new THREE.Float32BufferAttribute(vertices, 3)
+        )
+      }
+      let material = this.material.node
+      const nodeMeshes = new THREE.Points(geometry, material)
+      nodeMeshes.userData.version = 0
+      nodeMeshes.userData.type = 'nodeMeshes'
+      nodeMeshes.userData.meshId = null
+      nodeMeshes.userData.polygonId = null
+      nodeMeshes.matrixAutoUpdate = false
+      this.meshes.nodeMeshes = nodeMeshes
+      this.scene.add(nodeMeshes)
     }
-}
+  }
+}

package/src/helper/render/obstacle.js

@@ -1,55 +1,57 @@
 import * as THREE from 'three'
 import {
   getBufferObstacleGeometry,
-  getBufferObstacleSideGeometry,
+  getBufferObstacleSideGeometry
 } from './geometryHandler'
 export default {
-    methods:{
-      renderObstacles() {
-        this.clearByType('obstacleMeshes')
-  
-        this.roofs.forEach((roofPolygon) => {
-          roofPolygon.holes
-            .filter((poly) => poly.layer == 'obstacle')
-            .forEach((obstaclePolygon) => {
-              const geometry = getBufferObstacleGeometry(
-                obstaclePolygon,
-                roofPolygon
-              )
-  
-              const geometrySide = getBufferObstacleSideGeometry(
-                obstaclePolygon,
-                roofPolygon
-              )
-              if (geometry && geometrySide) {
-                const mesh = new THREE.Mesh(geometry, this.material.roof)
-                const meshSide = new THREE.Mesh(geometrySide, this.material.wall)
-                this.applyTextureOnMesh(this.material.roof,mesh)
+  methods: {
+    renderObstacles() {
+      this.clearByType('obstacleMeshes')
 
-                mesh.userData.version = obstaclePolygon.version
-                mesh.userData.type = 'obstacleMeshes'
-                mesh.userData.meshId = obstaclePolygon.id + '-' + roofPolygon.id + '_top'
-                mesh.userData.polygonId = obstaclePolygon.id
-                meshSide.userData.version = obstaclePolygon.version
-                meshSide.userData.type = 'obstacleMeshes'
-                meshSide.userData.meshId = obstaclePolygon.id + '-' + roofPolygon.id + '_side'
-                meshSide.userData.polygonId = obstaclePolygon.id
-               
-                mesh.matrixAutoUpdate = false
-                meshSide.matrixAutoUpdate = false
-                mesh.frustumCulled = false
-                meshSide.frustumCulled = false
-                this.scene.add(mesh)
-                this.scene.add(meshSide)
-                this.meshes.obstacleMeshes[
-                  obstaclePolygon.id + '-' + roofPolygon.id + '_top'
-                ] = mesh
-                this.meshes.obstacleMeshes[
-                  obstaclePolygon.id + '-' + roofPolygon.id + '_side'
-                ] = meshSide
-              }
-            })
-        })
-      },
+      this.roofs.forEach((roofPolygon) => {
+        roofPolygon.holes
+          .filter((poly) => poly.layer == 'obstacle')
+          .forEach((obstaclePolygon) => {
+            const geometry = getBufferObstacleGeometry(
+              obstaclePolygon,
+              roofPolygon
+            )
+
+            const geometrySide = getBufferObstacleSideGeometry(
+              obstaclePolygon,
+              roofPolygon
+            )
+            if (geometry && geometrySide) {
+              const mesh = new THREE.Mesh(geometry, this.material.roof)
+              const meshSide = new THREE.Mesh(geometrySide, this.material.wall)
+              this.applyTextureOnMesh(this.material.roof, mesh)
+
+              mesh.userData.version = obstaclePolygon.version
+              mesh.userData.type = 'obstacleMeshes'
+              mesh.userData.meshId =
+                obstaclePolygon.id + '-' + roofPolygon.id + '_top'
+              mesh.userData.polygonId = obstaclePolygon.id
+              meshSide.userData.version = obstaclePolygon.version
+              meshSide.userData.type = 'obstacleMeshes'
+              meshSide.userData.meshId =
+                obstaclePolygon.id + '-' + roofPolygon.id + '_side'
+              meshSide.userData.polygonId = obstaclePolygon.id
+
+              mesh.matrixAutoUpdate = false
+              meshSide.matrixAutoUpdate = false
+              mesh.frustumCulled = false
+              meshSide.frustumCulled = false
+              this.scene.add(mesh)
+              this.scene.add(meshSide)
+              this.meshes.obstacleMeshes[
+                obstaclePolygon.id + '-' + roofPolygon.id + '_top'
+              ] = mesh
+              this.meshes.obstacleMeshes[
+                obstaclePolygon.id + '-' + roofPolygon.id + '_side'
+              ] = meshSide
+            }
+          })
+      })
     }
-}
+  }
+}

package/src/helper/render/panel.js

@@ -3,88 +3,94 @@ import {
   getBufferPanelGeometry,
   updateBufferPanelGeometry,
   getBufferPanelSideGeometry,
-  updateBufferPanelSideGeometry,
+  updateBufferPanelSideGeometry
 } from './geometryHandler'
 export default {
-    methods:{
-      renderPanels() {
-        this.clearRemovedOnes('panelsMeshes')
-        Object.values(this.meshes.panelsMeshes).forEach((mesh) => {
-          //clear UserDeactivatedModules
-          if (
-            this.polygons.find(
-              (poly) =>
-                poly.id == mesh.userData.polygonId &&
-                poly.layer == 'user_deactivated_panel'
-            )
-          ) {
-            this.clearMesh(mesh)
+  methods: {
+    renderPanels() {
+      this.clearRemovedOnes('panelsMeshes')
+      Object.values(this.meshes.panelsMeshes).forEach((mesh) => {
+        //clear UserDeactivatedModules
+        if (
+          this.polygons.find(
+            (poly) =>
+              poly.id == mesh.userData.polygonId &&
+              poly.layer == 'user_deactivated_panel'
+          )
+        ) {
+          this.clearMesh(mesh)
+        }
+        //clear panel on moduleField with overriden number of panel
+        let panel = this.polygons.find(
+          (poly) => mesh.userData.polygonId == poly.id
+        )
+        if (!panel || panel.moduleField.data.number_of_panels_override) {
+          this.clearMesh(mesh)
+        }
+      })
+
+      this.panels.forEach((panelPolygon) => {
+        //definition of the material
+        if (panelPolygon.moduleField.data.number_of_panels_override) return
+        let material =
+          this.material.panel['default_' + this.moduleTextureVersionId]
+        material.transparent = true
+        material.opacity = this.panelOpacity
+        if (panelPolygon.moduleField.pvData) {
+          let pvId = panelPolygon.moduleField.pvData.id
+          if (this.material.panel[pvId]) {
+            material = this.material.panel[pvId]
+          }
+        } else if (panelPolygon.moduleField.data) {
+          let pvId = panelPolygon.moduleField.data.component_id_pv_module
+          if (this.material.panel[pvId]) {
+            material = this.material.panel[pvId]
           }
-          //clear panel on moduleField with overriden number of panel
-          let panel=this.polygons.find(poly=>mesh.userData.polygonId==poly.id)
-          if (
-            !panel || panel.moduleField.data.number_of_panels_override
-          ) {
-            this.clearMesh(mesh)
+        }
+
+        if (
+          !this.meshes.panelsMeshes[panelPolygon.id + '_top'] ||
+          !this.meshes.panelsMeshes[panelPolygon.id + '_side']
+        ) {
+          const geometry = getBufferPanelGeometry(panelPolygon)
+          const geometrySide = getBufferPanelSideGeometry(panelPolygon)
+
+          if (geometry && geometrySide) {
+            const mesh = new THREE.Mesh(geometry, material)
+            const meshSide = new THREE.Mesh(geometrySide, this.material.wall)
+            mesh.userData.version = panelPolygon.version
+            mesh.userData.type = 'panelsMeshes'
+            mesh.userData.meshId = panelPolygon.id + '_top'
+            mesh.userData.polygonId = panelPolygon.id
+            meshSide.userData.version = panelPolygon.version
+            meshSide.userData.type = 'panelsMeshes'
+            meshSide.userData.meshId = panelPolygon.id + '_side'
+            meshSide.userData.polygonId = panelPolygon.id
+            geometry.dispose()
+            geometrySide.dispose()
+            this.scene.add(mesh)
+            this.scene.add(meshSide)
+            mesh.matrixAutoUpdate = false
+            meshSide.matrixAutoUpdate = false
+            this.meshes.panelsMeshes[panelPolygon.id + '_top'] = mesh
+            this.meshes.panelsMeshes[panelPolygon.id + '_side'] = meshSide
           }
-        })
-  
-        this.panels.forEach((panelPolygon) => {
-          //definition of the material
-          if(panelPolygon.moduleField.data.number_of_panels_override) return
-           let material = this.material.panel['default_'+this.moduleTextureVersionId]
-           material.transparent=true
-           material.opacity=this.panelOpacity
-           if (panelPolygon.moduleField.pvData) {
-             let pvId = panelPolygon.moduleField.pvData.id
-             if (this.material.panel[pvId]) {
-               material = this.material.panel[pvId]
-             }
-           }else if(panelPolygon.moduleField.data){
-            let pvId = panelPolygon.moduleField.data.component_id_pv_module
-            if (this.material.panel[pvId]) {
-              material = this.material.panel[pvId]
-            }
-           }
-  
-          if (
-            !this.meshes.panelsMeshes[panelPolygon.id + '_top'] ||
-            !this.meshes.panelsMeshes[panelPolygon.id + '_side'] 
-          ) {
-            const geometry = getBufferPanelGeometry(panelPolygon)
-            const geometrySide = getBufferPanelSideGeometry(panelPolygon)
-  
-            if (geometry && geometrySide) {
-  
-                const mesh = new THREE.Mesh(geometry, material)
-                const meshSide = new THREE.Mesh(geometrySide, this.material.wall)
-                mesh.userData.version = panelPolygon.version
-                mesh.userData.type = 'panelsMeshes'
-                mesh.userData.meshId = panelPolygon.id + '_top'
-                mesh.userData.polygonId = panelPolygon.id
-                meshSide.userData.version = panelPolygon.version
-                meshSide.userData.type = 'panelsMeshes'
-                meshSide.userData.meshId = panelPolygon.id + '_side'
-                meshSide.userData.polygonId = panelPolygon.id
-                geometry.dispose()
-                geometrySide.dispose()
-                this.scene.add(mesh)
-                this.scene.add(meshSide)
-                mesh.matrixAutoUpdate = false
-                meshSide.matrixAutoUpdate = false
-                this.meshes.panelsMeshes[panelPolygon.id + '_top'] = mesh
-                this.meshes.panelsMeshes[panelPolygon.id + '_side'] = meshSide
-            }  
-          }else{
-            const topMesh=this.meshes.panelsMeshes[panelPolygon.id + '_top']
-            const sideMesh=this.meshes.panelsMeshes[panelPolygon.id + '_side']
-            if(panelPolygon.version>topMesh.userData.version){
-              topMesh.geometry=updateBufferPanelGeometry(panelPolygon,topMesh.geometry)
-              sideMesh.geometry=updateBufferPanelSideGeometry(panelPolygon,sideMesh.geometry)
-            }
-            topMesh.material= material
+        } else {
+          const topMesh = this.meshes.panelsMeshes[panelPolygon.id + '_top']
+          const sideMesh = this.meshes.panelsMeshes[panelPolygon.id + '_side']
+          if (panelPolygon.version > topMesh.userData.version) {
+            topMesh.geometry = updateBufferPanelGeometry(
+              panelPolygon,
+              topMesh.geometry
+            )
+            sideMesh.geometry = updateBufferPanelSideGeometry(
+              panelPolygon,
+              sideMesh.geometry
+            )
           }
-        })
-      },
+          topMesh.material = material
+        }
+      })
     }
-}
+  }
+}

package/src/helper/render/projectionMaterial.js

@@ -1,57 +1,65 @@
 export default {
-    methods:{
-      reorderRoofMaterials(){
-        this.material.roof.sort((a,b)=>{
-            let aPrio=a.priority || 0
-            let bPrio=b.priority || 0
-            return aPrio-bPrio
-        })
-      },
-      async updateProjectionMaterials(){
-        this.setImageOverlayCameraPosition()
-        let materialPromises=[
-          this.getMapProjectionMaterial(),
-          this.getImageOverlayMaterial()
-        ]
-        let materials = await Promise.all(materialPromises)
-        this.mapProjectionMaterial = materials[0] 
-        this.imageOverlayMaterial= materials[1]
+  methods: {
+    reorderRoofMaterials() {
+      this.material.roof.sort((a, b) => {
+        let aPrio = a.priority || 0
+        let bPrio = b.priority || 0
+        return aPrio - bPrio
+      })
+    },
+    async updateProjectionMaterials() {
+      this.setImageOverlayCameraPosition()
+      let materialPromises = [
+        this.getMapProjectionMaterial(),
+        this.getImageOverlayMaterial()
+      ]
+      let materials = await Promise.all(materialPromises)
+      this.mapProjectionMaterial = materials[0]
+      this.imageOverlayMaterial = materials[1]
 
-        let index=this.material.roof.findIndex(material=>material.userData.type=="mapProjectionMaterial")
-        if(this.mapProjectionMaterial){
-          if(index>=0){
-            this.material.roof[index]=this.mapProjectionMaterial
-            this.material.roof=[...this.material.roof]
-          }else{
-            this.material.roof=[...this.material.roof,this.mapProjectionMaterial]
-            this.reorderRoofMaterials()
-          }
-        }else if(index>=0){
-            this.material.roof[index].dispose()
-            this.material.roof.splice(index,1)
-            this.material.roof=[...this.material.roof]
-            this.reorderRoofMaterials()
+      let index = this.material.roof.findIndex(
+        (material) => material.userData.type == 'mapProjectionMaterial'
+      )
+      if (this.mapProjectionMaterial) {
+        if (index >= 0) {
+          this.material.roof[index] = this.mapProjectionMaterial
+          this.material.roof = [...this.material.roof]
+        } else {
+          this.material.roof = [
+            ...this.material.roof,
+            this.mapProjectionMaterial
+          ]
+          this.reorderRoofMaterials()
         }
+      } else if (index >= 0) {
+        this.material.roof[index].dispose()
+        this.material.roof.splice(index, 1)
+        this.material.roof = [...this.material.roof]
+        this.reorderRoofMaterials()
+      }
 
-        index=this.material.roof.findIndex(material=> material.userData.type=="imageOverlayMaterial")
-        if(this.imageOverlayMaterial){
-          if(index>=0){
-            this.material.roof[index]=this.imageOverlayMaterial
-            this.material.roof=[...this.material.roof]
-          }else{
-            this.material.roof=[...this.material.roof,this.imageOverlayMaterial]
-            this.reorderRoofMaterials()
-          }
-        }else if(index>=0){
-          this.material.roof[index].dispose()
-          this.material.roof.splice(index,1)
-          this.material.roof=[...this.material.roof]
+      index = this.material.roof.findIndex(
+        (material) => material.userData.type == 'imageOverlayMaterial'
+      )
+      if (this.imageOverlayMaterial) {
+        if (index >= 0) {
+          this.material.roof[index] = this.imageOverlayMaterial
+          this.material.roof = [...this.material.roof]
+        } else {
+          this.material.roof = [
+            ...this.material.roof,
+            this.imageOverlayMaterial
+          ]
           this.reorderRoofMaterials()
         }
-        this.renderImageOverlayOnBackground()
-        this.applyTextureOnRoofs()
-      },
-     
-      
+      } else if (index >= 0) {
+        this.material.roof[index].dispose()
+        this.material.roof.splice(index, 1)
+        this.material.roof = [...this.material.roof]
+        this.reorderRoofMaterials()
+      }
+      this.renderImageOverlayOnBackground()
+      this.applyTextureOnRoofs()
     }
-}
+  }
+}