@eturnity/eturnity_3d 6.29.0 → 6.29.2

package/src/helper/render/node.js

@@ -0,0 +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)
+          },
+    }
+}

package/src/helper/render/obstacle.js

@@ -0,0 +1,61 @@
+import * as THREE from 'three'
+import {
+  getBufferObstacleGeometry,
+  getBufferObstacleSideGeometry,
+} from './geometryHandler'
+import { material } from '../materials'
+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, material.wall)
+                mesh.material=this.material.roof
+                if(this.material.roof && this.material.roof.project){
+                  this.material.roof.project(mesh)
+                }else{
+                  mesh.material=this.material.wall
+                }
+
+                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

@@ -0,0 +1,88 @@
+import * as THREE from 'three'
+import {
+  getBufferPanelGeometry,
+  updateBufferPanelGeometry,
+  getBufferPanelSideGeometry,
+  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)
+          }
+          //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]
+           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
+          }
+        })
+      },
+    }
+}

package/src/helper/render/roof.js

@@ -0,0 +1,134 @@
+import * as THREE from 'three'
+import {
+  maximumGapLimit,
+} from '../../config'
+import {
+  getBufferRoofGeometry,
+  updateBufferRoofGeometry,
+} from './geometryHandler'
+import { intersectOutlines, verticalProjectionOnPlane } from '@eturnity/eturnity_maths'
+
+export default {
+    methods:{
+        updateRoofGeometry(geometry, roofPolygon) {
+            const roofOutline = roofPolygon.outline
+            let cropedHolesOutline = roofPolygon.holes
+            .filter((h) => h.layer == 'obstacle')
+            .map((h) => {
+                //let's crop obstacle with roof outline
+                const cropedHoleOutline =
+                intersectOutlines(h.outline, roofPolygon.outline)[0] || []
+                const outline = cropedHoleOutline.map((p) => {
+                return {
+                    x: p.x,
+                    y: p.y,
+                    z: verticalProjectionOnPlane(
+                    p,
+                    roofPolygon.normalVector,
+                    roofPolygon.flatOutline[0]
+                    ).z
+                }
+                })
+                return outline
+            })
+
+            cropedHolesOutline = cropedHolesOutline.filter((outline) => !!outline)
+            geometry = updateBufferRoofGeometry(
+            roofOutline,
+            cropedHolesOutline,
+            geometry
+            )
+
+            return geometry
+        },
+        createRoofGeometry(roofPolygon) {
+            const roofOutline = roofPolygon.outline
+            let cropedHolesOutline = roofPolygon.holes
+            .filter((h) => h.layer == 'obstacle')
+            .map((h) => {
+                //let's crop obstacle with roof outline
+                const cropedHoleOutline =
+                intersectOutlines(h.outline, roofPolygon.outline)[0] || []
+                const outline = cropedHoleOutline.map((p) => {
+                return {
+                    x: p.x,
+                    y: p.y,
+                    z: verticalProjectionOnPlane(
+                    p,
+                    roofPolygon.normalVector,
+                    roofPolygon.flatOutline[0]
+                    ).z
+                }
+                })
+                return outline
+            })
+
+            cropedHolesOutline = cropedHolesOutline.filter((outline) => !!outline)
+            let geometry = getBufferRoofGeometry(roofOutline, cropedHolesOutline)
+
+            return geometry
+        },
+        renderRoofs() {
+        this.clearRemovedOnes('roofMeshes')
+        this.roofs.forEach((roofPolygon) => {
+            let mesh
+            let geometry
+            if (
+            this.meshes.roofMeshes[roofPolygon.id] &&
+            this.meshes.roofMeshes[roofPolygon.id].userData.version <
+                roofPolygon.version
+            ) {
+            //update mesh
+            mesh = this.meshes.roofMeshes[roofPolygon.id]
+            geometry = mesh.geometry
+            geometry = this.updateRoofGeometry(geometry, roofPolygon)
+            mesh.geometry = geometry
+            if(this.material.roof){
+                mesh.material=this.material.roof
+                if(this.material.roof && this.material.roof.project) this.material.roof.project(mesh)
+            }
+            mesh.frustumCulled = false
+            mesh.updateMatrix()
+            }
+            if (!this.meshes.roofMeshes[roofPolygon.id]) {
+            //create
+            geometry = this.createRoofGeometry(roofPolygon)
+            if (geometry) {
+                mesh = new THREE.Mesh(geometry, this.material.roof)
+                mesh.userData.version = roofPolygon.version
+                mesh.userData.type = 'roofMeshes'
+                mesh.userData.meshId = roofPolygon.id
+                mesh.userData.polygonId = roofPolygon.id
+                mesh.matrixAutoUpdate = false
+                this.scene.add(mesh)
+                if(this.material.roof){
+                mesh.material=this.material.roof
+                if(this.material.roof.project) this.material.roof.project(mesh)
+                }
+                mesh.frustumCulled = false
+                this.meshes.roofMeshes[roofPolygon.id] = mesh
+            }
+            }
+        })
+        },
+        renderFlatRoofs() {
+            //this.clearRemovedOnes('flatRoofMeshes')
+            this.clearByType('flatRoofMeshes')
+            this.roofs.forEach((roofPolygon) => {
+            //if(this.meshes.flatRoofMeshes[roofPolygon.id])
+            if(roofPolygon.maximumGap < maximumGapLimit) return
+            let geometry = getBufferRoofGeometry(roofPolygon.flatOutline)
+            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)
+                this.meshes.flatRoofMeshes[roofPolygon.id] = mesh
+            }
+            })
+        },
+    }
+}