@eturnity/eturnity_3d 6.34.0 → 6.34.1

package/src/helper/render/geometryHandler.js

@@ -15,7 +15,7 @@ export function getTriangleVerticesFromOutline(
   polygonOutline,
   holesOutlines = []
 ) {
-  if(polygonOutline.length==0){
+  if (polygonOutline.length == 0) {
     return new Float32Array([])
   }
   var dataVertices = polygonOutline
@@ -24,25 +24,26 @@ export function getTriangleVerticesFromOutline(
     })
     .flat()
   let holesStartingIndexes = []
-  let holesVertices=[]
+  let holesVertices = []
   //we group building and wall vertices and give the starting index of each obstacles.
   if (holesOutlines.length > 0) {
-    const HoleIndexOffset = (dataVertices.length / 3)+1
+    const HoleIndexOffset = dataVertices.length / 3 + 1
     holesStartingIndexes.push(HoleIndexOffset)
-    let lastIndex=HoleIndexOffset
-    for(let k=0;k<holesOutlines.length-1;k++){
-      let newIndex=lastIndex+(holesOutlines[k].length)
+    let lastIndex = HoleIndexOffset
+    for (let k = 0; k < holesOutlines.length - 1; k++) {
+      let newIndex = lastIndex + holesOutlines[k].length
       holesStartingIndexes.push(newIndex)
-      lastIndex=newIndex
+      lastIndex = newIndex
     }
-    holesStartingIndexes=[...new Set(holesStartingIndexes)]
+    holesStartingIndexes = [...new Set(holesStartingIndexes)]
     holesVertices = holesOutlines
       .map((holeOutline) => {
         return holeOutline.map((p) => {
           return [p.x / 1000, p.y / 1000, p.z / 1000]
         })
       })
-      .flat().flat()
+      .flat()
+      .flat()
   }
   let lastPoint = polygonOutline[polygonOutline.length - 1]
   let lastVertex = [lastPoint.x / 1000, lastPoint.y / 1000, lastPoint.z / 1000]
@@ -50,9 +51,9 @@ export function getTriangleVerticesFromOutline(
   dataVertices.push(...holesVertices)
 
   var triangles = []
-  try{
-    triangles=earcut(dataVertices, holesStartingIndexes, 3)
-  }catch(err){
+  try {
+    triangles = earcut(dataVertices, holesStartingIndexes, 3)
+  } catch (err) {
     console.error(err)
   }
   const triangleVertices = []
@@ -65,45 +66,61 @@ export function getTriangleVerticesFromOutline(
   })
   return triangleVertices
 }
-export function updateBufferRoofGeometry(polygonOutline,holesOutline=[],geometry) {
+export function updateBufferRoofGeometry(
+  polygonOutline,
+  holesOutline = [],
+  geometry
+) {
   //Calcul of triangles using cutear algo
-  const triangleVertices = getTriangleVerticesFromOutline(polygonOutline,holesOutline)
-  if(hasNaN(triangleVertices)){return null}
+  const triangleVertices = getTriangleVerticesFromOutline(
+    polygonOutline,
+    holesOutline
+  )
+  if (hasNaN(triangleVertices)) {
+    return null
+  }
   const vertices = new Float32Array(triangleVertices)
   // itemSize = 3 because there are 3 values (components) per vertex
-  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]
+  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]
     }
-
-  }else{
+  } else {
     geometry.dispose()
-    geometry=null
-    geometry = new THREE.BufferGeometry()    
-    geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+    geometry = null
+    geometry = new THREE.BufferGeometry()
+    geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
   }
-  geometry.setDrawRange( 0, vertices.length/3 );
+  geometry.setDrawRange(0, vertices.length / 3)
   geometry.computeVertexNormals()
-  geometry.attributes.position.needsUpdate = true;
+  geometry.attributes.position.needsUpdate = true
   return geometry
 }
 
-export function getBufferRoofGeometry(polygonOutline,holesOutline=[]) {
-  const geometry = new THREE.BufferGeometry()    
+export function getBufferRoofGeometry(polygonOutline, holesOutline = []) {
+  const geometry = new THREE.BufferGeometry()
   //Calcul of triangles using cutear algo
-  const triangleVertices = getTriangleVerticesFromOutline(polygonOutline,holesOutline)
-  if(hasNaN(triangleVertices)){return null}
+  const triangleVertices = getTriangleVerticesFromOutline(
+    polygonOutline,
+    holesOutline
+  )
+  if (hasNaN(triangleVertices)) {
+    return null
+  }
   const vertices = new Float32Array(triangleVertices)
   // itemSize = 3 because there are 3 values (components) per vertex
+  var uvs = new Float32Array([1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0])
   geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
+  geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2))
   geometry.computeVertexNormals()
   return geometry
 }
 
-
-
-export function getWallVertices(polygon){
+export function getWallVertices(polygon) {
   const length = polygon.outline.length
   const trianglesVertices = []
   polygon.outline.forEach((p_up_0, index) => {
@@ -134,13 +151,18 @@ export function getWallVertices(polygon){
       ]
     )
   })
- 
-  polygon.holes.forEach((hole)=>{
-    let obstacleWallOutline=intersectOutlines(hole.outline, polygon.outline)[0]||[]
-    obstacleWallOutline=obstacleWallOutline.map(p=>{
+
+  polygon.holes.forEach((hole) => {
+    let obstacleWallOutline =
+      intersectOutlines(hole.outline, polygon.outline)[0] || []
+    obstacleWallOutline = obstacleWallOutline.map((p) => {
       return {
         ...p,
-        z:verticalProjectionOnPlane(p,polygon.normalVector,polygon.flatOutline[0]).z
+        z: verticalProjectionOnPlane(
+          p,
+          polygon.normalVector,
+          polygon.flatOutline[0]
+        ).z
       }
     })
     const lengthHole = obstacleWallOutline.length
@@ -173,52 +195,59 @@ export function getWallVertices(polygon){
       )
     })
   })
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   return vertices
 }
-export function updateBufferWallGeometry(polygon,geometry) {
+export function updateBufferWallGeometry(polygon, geometry) {
   //geometry = new THREE.BufferGeometry()
   //Calcul of triangles using cutear algo
-  const vertices=getWallVertices(polygon)
+  const vertices = getWallVertices(polygon)
   // itemSize = 3 because there are 3 values (components) per vertex
-  
-  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]
+
+  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.setDrawRange(0, vertices.length / 3)
+  } else {
     geometry.dispose()
-    geometry=null
-    geometry = new THREE.BufferGeometry()    
-    geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+    geometry = null
+    geometry = new THREE.BufferGeometry()
+    geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
   }
   geometry.computeVertexNormals()
-  geometry.attributes.position.needsUpdate = true;
+  geometry.attributes.position.needsUpdate = true
   return geometry
 }
 
 export function getBufferWallGeometry(polygon) {
   const geometry = new THREE.BufferGeometry()
   //Calcul of triangles using cutear algo
-  const vertices=getWallVertices(polygon)
+  const vertices = getWallVertices(polygon)
   // itemSize = 3 because there are 3 values (components) per vertex
   geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
   geometry.computeVertexNormals()
-  
+
   return geometry
 }
 
 export function getBufferObstacleGeometry(obstaclePolygon, roofPolygon) {
-  let obstacleHeight 
-  if(obstaclePolygon.isParallel){
+  let obstacleHeight
+  if (obstaclePolygon.isParallel) {
     obstacleHeight = parseInt(obstaclePolygon.height || 0)
-  }else{
-    obstacleHeight = parseInt(obstaclePolygon.heightReference + obstaclePolygon.height || 0)
+  } else {
+    obstacleHeight = parseInt(
+      obstaclePolygon.heightReference + obstaclePolygon.height || 0
+    )
   }
-  
+
   //get lowest verticalProjection
   const normalVector = roofPolygon.normalVector
   const passByPoint = roofPolygon.flatOutline[0]
@@ -232,8 +261,9 @@ export function getBufferObstacleGeometry(obstaclePolygon, roofPolygon) {
   const topHeight = obstacleHeight
 
   const geometry = new THREE.BufferGeometry()
-  const cropedHoleOutline=intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
-  
+  const cropedHoleOutline =
+    intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
+
   //Calcul of triangles using cutear algo
   const trianglesVertices = []
   const obstacleOutlineTop = []
@@ -255,7 +285,9 @@ export function getBufferObstacleGeometry(obstaclePolygon, roofPolygon) {
   })
   trianglesVertices.push(...getTriangleVerticesFromOutline(obstacleOutlineTop))
 
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   // itemSize = 3 because there are 3 values (components) per vertex
   geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
@@ -264,13 +296,15 @@ export function getBufferObstacleGeometry(obstaclePolygon, roofPolygon) {
 }
 
 export function getBufferObstacleSideGeometry(obstaclePolygon, roofPolygon) {
-  let obstacleHeight 
-  if(obstaclePolygon.isParallel){
+  let obstacleHeight
+  if (obstaclePolygon.isParallel) {
     obstacleHeight = parseInt(obstaclePolygon.height || 0)
-  }else{
-    obstacleHeight = parseInt(obstaclePolygon.heightReference + obstaclePolygon.height || 0)
+  } else {
+    obstacleHeight = parseInt(
+      obstaclePolygon.heightReference + obstaclePolygon.height || 0
+    )
   }
-  
+
   const normalVector = roofPolygon.normalVector
   const passByPoint = roofPolygon.flatOutline[0]
 
@@ -283,7 +317,8 @@ export function getBufferObstacleSideGeometry(obstaclePolygon, roofPolygon) {
   const topHeight = obstacleHeight
 
   const geometry = new THREE.BufferGeometry()
-  const cropedHoleOutline=intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
+  const cropedHoleOutline =
+    intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
   //Calcul of triangles using cutear algo
   const obstacleLength = cropedHoleOutline.length
   const trianglesVertices = []
@@ -334,7 +369,9 @@ export function getBufferObstacleSideGeometry(obstaclePolygon, roofPolygon) {
     )
   })
 
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   // itemSize = 3 because there are 3 values (components) per vertex
   geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
@@ -360,7 +397,9 @@ export function getBufferModuleFieldGeometry(moduleFieldPolygon) {
   trianglesVertices.push(
     ...getTriangleVerticesFromOutline(moduleFieldOutlineTop)
   )
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   var uvs = new Float32Array([
     1, 1, 0, 1, 0, 0,
@@ -375,8 +414,8 @@ export function getBufferModuleFieldGeometry(moduleFieldPolygon) {
   return geometry
 }
 
-export function getBufferImageOverlayGeometry(corners){
-  corners.forEach(p=>p.z=0)
+export function getBufferImageOverlayGeometry(corners) {
+  corners.forEach((p) => (p.z = 0))
   let normalVector = getNormalVectorFrom3Points(
     corners[0],
     corners[1],
@@ -390,7 +429,9 @@ export function getBufferImageOverlayGeometry(corners){
   //Calcul of triangles using cutear algo
   const trianglesVertices = []
   trianglesVertices.push(...getTriangleVerticesFromOutline(corners))
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   var A = corners[2]
   var B = corners[3]
@@ -401,23 +442,15 @@ export function getBufferImageOverlayGeometry(corners){
   let uvs
   if (AB < AC) {
     uvs = new Float32Array([
-      0, 1, 
-      0, 0, 
-      1, 0,
+      0, 1, 0, 0, 1, 0,
 
-      0, 1, 
-      1, 0, 
-      1, 1
+      0, 1, 1, 0, 1, 1
     ])
-  }else{
+  } else {
     uvs = new Float32Array([
-      0, 0, 
-      1, 0, 
-      1, 1,
-  
-      1, 0, 
-      0, 1, 
-      1, 1
+      0, 0, 1, 0, 1, 1,
+
+      1, 0, 0, 1, 1, 1
     ])
   }
   geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
@@ -449,7 +482,9 @@ export function getBufferPanelGeometry(panelPolygon) {
   })
   trianglesVertices.push(...getTriangleVerticesFromOutline(panelOutlineTop))
 
-  if(hasNaN(trianglesVertices)){return null}
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
   const vertices = new Float32Array(trianglesVertices)
   var A = panelPolygon.outline[2]
   var B = panelPolygon.outline[3]
@@ -460,23 +495,15 @@ export function getBufferPanelGeometry(panelPolygon) {
   let uvs
   if (AB < AC) {
     uvs = new Float32Array([
-      0, 1, 
-      0, 0, 
-      1, 0,
+      0, 1, 0, 0, 1, 0,
 
-      0, 1, 
-      1, 0, 
-      1, 1
+      0, 1, 1, 0, 1, 1
     ])
-  }else{
+  } else {
     uvs = new Float32Array([
-      0, 0, 
-      1, 0, 
-      1, 1,
-  
-      1, 0, 
-      0, 1, 
-      1, 1
+      0, 0, 1, 0, 1, 1,
+
+      1, 0, 0, 1, 1, 1
     ])
   }
 
@@ -486,13 +513,13 @@ export function getBufferPanelGeometry(panelPolygon) {
   geometry.computeVertexNormals()
   return geometry
 }
-export function updateBufferPanelGeometry(panelPolygon,geometry){
-  geometry=updateBufferRoofGeometry(panelPolygon.outline,[],geometry)
+export function updateBufferPanelGeometry(panelPolygon, geometry) {
+  geometry = updateBufferRoofGeometry(panelPolygon.outline, [], geometry)
   return geometry
 }
 
-export function updateBufferPanelSideGeometry(panelPolygon,geometry){
-  geometry=updateBufferRoofGeometry(panelPolygon.outline,[],geometry)
+export function updateBufferPanelSideGeometry(panelPolygon, geometry) {
+  geometry = updateBufferRoofGeometry(panelPolygon.outline, [], geometry)
   return geometry
 }
 export function getBufferPanelSideGeometry(panelPolygon) {
@@ -544,8 +571,10 @@ export function getBufferPanelSideGeometry(panelPolygon) {
       ]
     )
   })
-  if(hasNaN(trianglesVertices)){return null}
-  
+  if (hasNaN(trianglesVertices)) {
+    return null
+  }
+
   const vertices = new Float32Array(trianglesVertices)
 
   // itemSize = 3 because there are 3 values (components) per vertex
@@ -554,43 +583,52 @@ export function getBufferPanelSideGeometry(panelPolygon) {
   return geometry
 }
 
-export function getBufferRoofMarginGeometry(polygon,roofPolygon=null) {
+export function getBufferRoofMarginGeometry(polygon, roofPolygon = null) {
   const geometries = []
   const length = polygon.margins.innerOutline.length
-  
+
   polygon.margins.innerOutline.forEach((K, index) => {
     //check if distance ==0 then margin not displayed
     let geometry
-    const distance=polygon.margins.isSameMargin?polygon.margins.sameMargin:polygon.margins.distances[index]
-    if(distance<=0){
-        geometry=null
-    }else{
+    const distance = polygon.margins.isSameMargin
+      ? polygon.margins.sameMargin
+      : polygon.margins.distances[index]
+    if (distance <= 0) {
+      geometry = null
+    } else {
       const A = polygon.margins.outterOutline[index]
       const B = polygon.margins.outterOutline[(index + 1) % length]
       const J = polygon.margins.innerOutline[(index + 1) % length]
 
-      let marginOutline=[A,B,J,K]
-      if(roofPolygon){
-        marginOutline=intersectOutlines(marginOutline, roofPolygon.flatOutline)[0] || []
-        marginOutline=marginOutline.map(p=>{
+      let marginOutline = [A, B, J, K]
+      if (roofPolygon) {
+        marginOutline =
+          intersectOutlines(marginOutline, roofPolygon.flatOutline)[0] || []
+        marginOutline = marginOutline.map((p) => {
           return {
-            x:p.x,
-            y:p.y,
-            z:verticalProjectionOnPlane(p,roofPolygon.normalVector,roofPolygon.flatOutline[0]).z
+            x: p.x,
+            y: p.y,
+            z: verticalProjectionOnPlane(
+              p,
+              roofPolygon.normalVector,
+              roofPolygon.flatOutline[0]
+            ).z
           }
         })
       }
-      marginOutline=marginOutline.map(p=>{return {x:p.x,y:p.y,z:p.z+10}})
+      marginOutline = marginOutline.map((p) => {
+        return { x: p.x, y: p.y, z: p.z + 10 }
+      })
       geometry = new THREE.BufferGeometry()
 
       const trianglesVertices = []
-      
-      trianglesVertices.push(
-        ...getTriangleVerticesFromOutline(marginOutline)
-      )
-      if(hasNaN(trianglesVertices)){return null}
+
+      trianglesVertices.push(...getTriangleVerticesFromOutline(marginOutline))
+      if (hasNaN(trianglesVertices)) {
+        return null
+      }
       const vertices = new Float32Array(trianglesVertices)
-    
+
       geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
       geometry.computeVertexNormals()
     }