@eturnity/eturnity_3d 0.0.4

package/src/helper/geometryHandler.js

@@ -0,0 +1,606 @@
+import * as THREE from 'three'
+import { defaultBaseHeight } from '../config'
+import earcut from 'earcut'
+import {
+  verticalProjectionOnPlane,
+  addVector,
+  multiplyVector,
+  getNormalVectorFrom3Points,
+  hasNaN,
+  getDistanceBetweenPoints,
+  intersectOutlines
+} from '@eturnity/eturnity_maths'
+
+export function getTriangleVerticesFromOutline(
+  polygonOutline,
+  holesOutlines = []
+) {
+  if(polygonOutline.length==0){
+    return new Float32Array([])
+  }
+  var dataVertices = polygonOutline
+    .map((p) => {
+      return [p.x / 1000, p.y / 1000, p.z / 1000]
+    })
+    .flat()
+  let holesStartingIndexes = []
+  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
+    holesStartingIndexes.push(HoleIndexOffset)
+    let lastIndex=HoleIndexOffset
+    for(let k=0;k<holesOutlines.length-1;k++){
+      let newIndex=lastIndex+(holesOutlines[k].length)
+      holesStartingIndexes.push(newIndex)
+      lastIndex=newIndex
+    }
+    holesStartingIndexes=[...new Set(holesStartingIndexes)]
+    holesVertices = holesOutlines
+      .map((holeOutline) => {
+        return holeOutline.map((p) => {
+          return [p.x / 1000, p.y / 1000, p.z / 1000]
+        })
+      })
+      .flat().flat()
+  }
+  let lastPoint = polygonOutline[polygonOutline.length - 1]
+  let lastVertex = [lastPoint.x / 1000, lastPoint.y / 1000, lastPoint.z / 1000]
+  dataVertices.push(...lastVertex)
+  dataVertices.push(...holesVertices)
+
+  var triangles = []
+  try{
+    triangles=earcut(dataVertices, holesStartingIndexes, 3)
+  }catch(err){
+    console.error(err)
+  }
+  const triangleVertices = []
+  triangles.forEach((index) => {
+    triangleVertices.push(
+      dataVertices[3 * index],
+      dataVertices[3 * index + 1],
+      dataVertices[3 * index + 2]
+    )
+  })
+  return triangleVertices
+}
+export function updateBufferRoofGeometry(polygonOutline,holesOutline=[],geometry) {
+  //Calcul of triangles using cutear algo
+  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]
+    }
+
+  }else{
+    geometry.dispose()
+    geometry=null
+    geometry = new THREE.BufferGeometry()    
+    geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+  }
+  geometry.setDrawRange( 0, vertices.length/3 );
+  geometry.computeVertexNormals()
+  geometry.attributes.position.needsUpdate = true;
+  return geometry
+}
+
+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 vertices = new Float32Array(triangleVertices)
+  // itemSize = 3 because there are 3 values (components) per vertex
+  geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
+  geometry.computeVertexNormals()
+  return geometry
+}
+
+
+
+export function getWallVertices(polygon){
+  const length = polygon.outline.length
+  const trianglesVertices = []
+  polygon.outline.forEach((p_up_0, index) => {
+    const p_up_1 = polygon.outline[(index + 1) % length]
+    const p_bottom_0 = { ...p_up_0, z: 0 }
+    const p_bottom_1 = { ...p_up_1, z: 0 }
+
+    trianglesVertices.push(
+      ...[
+        p_up_0.x / 1000,
+        p_up_0.y / 1000,
+        p_up_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_bottom_1.x / 1000,
+        p_bottom_1.y / 1000,
+        p_bottom_1.z / 1000
+      ]
+    )
+  })
+ 
+  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
+      }
+    })
+    const lengthHole = obstacleWallOutline.length
+    obstacleWallOutline.forEach((p_up_0, index) => {
+      const p_up_1 = obstacleWallOutline[(index + 1) % lengthHole]
+      const p_bottom_0 = { ...p_up_0, z: 0 }
+      const p_bottom_1 = { ...p_up_1, z: 0 }
+
+      trianglesVertices.push(
+        ...[
+          p_up_0.x / 1000,
+          p_up_0.y / 1000,
+          p_up_0.z / 1000,
+          p_up_1.x / 1000,
+          p_up_1.y / 1000,
+          p_up_1.z / 1000,
+          p_bottom_0.x / 1000,
+          p_bottom_0.y / 1000,
+          p_bottom_0.z / 1000,
+          p_up_1.x / 1000,
+          p_up_1.y / 1000,
+          p_up_1.z / 1000,
+          p_bottom_0.x / 1000,
+          p_bottom_0.y / 1000,
+          p_bottom_0.z / 1000,
+          p_bottom_1.x / 1000,
+          p_bottom_1.y / 1000,
+          p_bottom_1.z / 1000
+        ]
+      )
+    })
+  })
+  if(hasNaN(trianglesVertices)){return null}
+  const vertices = new Float32Array(trianglesVertices)
+  return vertices
+}
+export function updateBufferWallGeometry(polygon,geometry) {
+  //geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  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]
+    }
+    geometry.setDrawRange( 0, vertices.length/3 );
+  }else{
+    geometry.dispose()
+    geometry=null
+    geometry = new THREE.BufferGeometry()    
+    geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+  }
+  geometry.computeVertexNormals()
+  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)
+  // 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){
+    obstacleHeight = parseInt(obstaclePolygon.height || 0)
+  }else{
+    obstacleHeight = parseInt(obstaclePolygon.heightReference + obstaclePolygon.height || 0)
+  }
+  
+  //get lowest verticalProjection
+  const normalVector = roofPolygon.normalVector
+  const passByPoint = roofPolygon.flatOutline[0]
+
+  // const minHeight = Math.min(
+  //   ...obstaclePolygon.outline.map(
+  //     (p) => verticalProjectionOnPlane(p, normalVector, passByPoint).z
+  //   )
+  // )
+  // const topHeight = minHeight + obstacleHeight
+  const topHeight = obstacleHeight
+
+  const geometry = new THREE.BufferGeometry()
+  const cropedHoleOutline=intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
+  
+  //Calcul of triangles using cutear algo
+  const trianglesVertices = []
+  const obstacleOutlineTop = []
+  cropedHoleOutline.forEach((p) => {
+    const p_bottom_0 = verticalProjectionOnPlane(p, normalVector, passByPoint)
+
+    let p_up_0
+    if (!obstaclePolygon.isParallel) {
+      p_up_0 = { ...p_bottom_0, z: topHeight }
+    } else {
+      const vectorFromBottomToTop = multiplyVector(obstacleHeight, {
+        x: 0,
+        y: 0,
+        z: 1
+      })
+      p_up_0 = addVector(p_bottom_0, vectorFromBottomToTop)
+    }
+    obstacleOutlineTop.push(p_up_0)
+  })
+  trianglesVertices.push(...getTriangleVerticesFromOutline(obstacleOutlineTop))
+
+  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))
+  geometry.computeVertexNormals()
+  return geometry
+}
+
+export function getBufferObstacleSideGeometry(obstaclePolygon, roofPolygon) {
+  let obstacleHeight 
+  if(obstaclePolygon.isParallel){
+    obstacleHeight = parseInt(obstaclePolygon.height || 0)
+  }else{
+    obstacleHeight = parseInt(obstaclePolygon.heightReference + obstaclePolygon.height || 0)
+  }
+  
+  const normalVector = roofPolygon.normalVector
+  const passByPoint = roofPolygon.flatOutline[0]
+
+  // const minHeight = Math.min(
+  //   ...obstaclePolygon.outline.map(
+  //     (p) => verticalProjectionOnPlane(p, normalVector, passByPoint).z
+  //   )
+  // )
+  // const topHeight = minHeight + obstacleHeight
+  const topHeight = obstacleHeight
+
+  const geometry = new THREE.BufferGeometry()
+  const cropedHoleOutline=intersectOutlines(obstaclePolygon.outline, roofPolygon.outline)[0] || []
+  //Calcul of triangles using cutear algo
+  const obstacleLength = cropedHoleOutline.length
+  const trianglesVertices = []
+  const obstacleOutlineTop = []
+  cropedHoleOutline.forEach((p, index) => {
+    const p_bottom_0 = verticalProjectionOnPlane(p, normalVector, passByPoint)
+    const p_bottom_1 = verticalProjectionOnPlane(
+      cropedHoleOutline[(index + 1) % obstacleLength],
+      normalVector,
+      passByPoint
+    )
+    let p_up_0
+    let p_up_1
+    if (!obstaclePolygon.isParallel) {
+      p_up_0 = { ...p_bottom_0, z: topHeight }
+      p_up_1 = { ...p_bottom_1, z: topHeight }
+    } else {
+      //const vectorFromBottomToTop=multiplyVector(obstacleHeight,{normalVector})
+      const vectorFromBottomToTop = multiplyVector(obstacleHeight, {
+        x: 0,
+        y: 0,
+        z: 1
+      })
+      p_up_0 = addVector(p_bottom_0, vectorFromBottomToTop)
+      p_up_1 = addVector(p_bottom_1, vectorFromBottomToTop)
+    }
+    trianglesVertices.push(
+      ...[
+        p_up_0.x / 1000,
+        p_up_0.y / 1000,
+        p_up_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_bottom_1.x / 1000,
+        p_bottom_1.y / 1000,
+        p_bottom_1.z / 1000
+      ]
+    )
+  })
+
+  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))
+  geometry.computeVertexNormals()
+  return geometry
+}
+
+export function getBufferModuleFieldGeometry(moduleFieldPolygon) {
+  const roofPolygon = moduleFieldPolygon.roof
+  const moduleHeight = 10
+  //get lowest verticalProjection
+  const normalVector = roofPolygon.normalVector
+
+  const moduleFieldOutlineTop = []
+  const geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  const trianglesVertices = []
+  moduleFieldPolygon.outline.forEach((p) => {
+    const vectorFromBottomToTop = multiplyVector(moduleHeight, normalVector)
+    let p_up_0 = addVector(p, vectorFromBottomToTop)
+    moduleFieldOutlineTop.push(p_up_0)
+  })
+  trianglesVertices.push(
+    ...getTriangleVerticesFromOutline(moduleFieldOutlineTop)
+  )
+  if(hasNaN(trianglesVertices)){return null}
+  const vertices = new Float32Array(trianglesVertices)
+  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 getBufferPanelGeometry(panelPolygon) {
+  let panelNormalVector = getNormalVectorFrom3Points(
+    panelPolygon.outline[0],
+    panelPolygon.outline[1],
+    panelPolygon.outline[2]
+  )
+  if (panelNormalVector.z < 0) {
+    panelNormalVector = multiplyVector(-1, panelNormalVector)
+  }
+  const roofPolygon = panelPolygon.roof
+  const panelHeight = parseInt(panelPolygon.height || 50)
+  //get lowest verticalProjection
+
+  const panelOutlineTop = []
+  const geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  const trianglesVertices = []
+  panelPolygon.outline.forEach((p) => {
+    const vectorFromBottomToTop = multiplyVector(panelHeight, panelNormalVector)
+    let p_up_0 = addVector(p, vectorFromBottomToTop)
+
+    panelOutlineTop.push(p_up_0)
+  })
+  trianglesVertices.push(...getTriangleVerticesFromOutline(panelOutlineTop))
+
+  if(hasNaN(trianglesVertices)){return null}
+  const vertices = new Float32Array(trianglesVertices)
+  var A = panelPolygon.outline[2]
+  var B = panelPolygon.outline[3]
+  var C = panelPolygon.outline[1]
+  var D = panelPolygon.outline[0]
+  const AB = getDistanceBetweenPoints(A, B)
+  const AC = getDistanceBetweenPoints(A, C)
+  let uvs
+  if (AB < AC) {
+    uvs = new Float32Array([
+      0, 1, 
+      0, 0, 
+      1, 0,
+
+      0, 1, 
+      1, 0, 
+      1, 1
+    ])
+  }else{
+    uvs = new Float32Array([
+      0, 0, 
+      1, 0, 
+      1, 1,
+  
+      1, 0, 
+      0, 1, 
+      1, 1
+    ])
+  }
+
+  geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
+  geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2))
+
+  geometry.computeVertexNormals()
+  return geometry
+}
+export function updateBufferPanelGeometry(panelPolygon,geometry){
+  geometry=updateBufferRoofGeometry(panelPolygon.outline,[],geometry)
+  return geometry
+}
+
+export function updateBufferPanelSideGeometry(panelPolygon,geometry){
+  geometry=updateBufferRoofGeometry(panelPolygon.outline,[],geometry)
+  return geometry
+}
+export function getBufferPanelSideGeometry(panelPolygon) {
+  let panelNormalVector = getNormalVectorFrom3Points(
+    panelPolygon.outline[0],
+    panelPolygon.outline[1],
+    panelPolygon.outline[2]
+  )
+  if (panelNormalVector.z < 0) {
+    panelNormalVector = multiplyVector(-1, panelNormalVector)
+  }
+  const roofPolygon = panelPolygon.roof
+  const panelHeight = parseInt(panelPolygon.height || 50)
+  // const normalVector = roofPolygon.normalVector
+  // const passByPoint = roofPolygon.flatOutline[0]
+
+  const geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  const panelLength = panelPolygon.outline.length
+  const trianglesVertices = []
+  const panelOutlineTop = []
+  panelPolygon.outline.forEach((p, index) => {
+    //const vectorFromBottomToTop=multiplyVector(obstacleHeight,{normalVector})
+    const p_bottom_0 = p
+    const p_bottom_1 = panelPolygon.outline[(index + 1) % panelLength]
+    const vectorFromBottomToTop = multiplyVector(panelHeight, panelNormalVector)
+    let p_up_0 = addVector(p_bottom_0, vectorFromBottomToTop)
+    let p_up_1 = addVector(p_bottom_1, vectorFromBottomToTop)
+    trianglesVertices.push(
+      ...[
+        p_up_0.x / 1000,
+        p_up_0.y / 1000,
+        p_up_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_bottom_0.x / 1000,
+        p_bottom_0.y / 1000,
+        p_bottom_0.z / 1000,
+        p_up_1.x / 1000,
+        p_up_1.y / 1000,
+        p_up_1.z / 1000,
+        p_bottom_1.x / 1000,
+        p_bottom_1.y / 1000,
+        p_bottom_1.z / 1000
+      ]
+    )
+  })
+  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))
+  geometry.computeVertexNormals()
+  return geometry
+}
+
+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 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=>{
+          return {
+            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}})
+      geometry = new THREE.BufferGeometry()
+
+      const trianglesVertices = []
+      
+      trianglesVertices.push(
+        ...getTriangleVerticesFromOutline(marginOutline)
+      )
+      if(hasNaN(trianglesVertices)){return null}
+      const vertices = new Float32Array(trianglesVertices)
+    
+      geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
+      geometry.computeVertexNormals()
+    }
+    geometries.push(geometry)
+  })
+  return geometries
+}
+
+export function getExtrusionGeometry(
+  solidsHolesMapData,
+  height = (defaultBaseHeight - 100) / 1000
+) {
+  const shapes = []
+  const getBezierPath = (segments) => {
+    const bezierPath = new THREE.Shape()
+    for (let i = 0; i < segments.length; i += 1) {
+      const curr = segments[i]
+      const next = segments[(i + 1) % segments.length]
+      const p = []
+      p[0] = curr
+      p[1] = curr
+      p[2] = next
+      p[3] = next
+
+      if (i === 0) {
+        bezierPath.moveTo(p[0].x / 1000, p[0].y / 1000)
+      }
+      bezierPath.bezierCurveTo(
+        p[1].x / 1000,
+        p[1].y / 1000,
+        p[2].x / 1000,
+        p[2].y / 1000,
+        p[3].x / 1000,
+        p[3].y / 1000
+      )
+    }
+
+    bezierPath.closePath()
+    return bezierPath
+  }
+  for (const shape of solidsHolesMapData) {
+    const solidShape = getBezierPath(shape.outline)
+    const holes = shape.holes
+    const holePaths = []
+    for (let i = 0; i < holes.length; i += 1) {
+      const holePath = getBezierPath(holes[i])
+      holePaths.push(holePath)
+    }
+    solidShape.holes = holePaths
+    shapes.push(solidShape)
+  }
+  const settings = {
+    depth: height,
+    curveSegments: 10,
+    bevelEnabled: false,
+    material: 0,
+    extrudeMaterial: 1
+  }
+
+  const geometry = new THREE.ExtrudeGeometry(shapes, settings)
+  return geometry
+}

package/src/helper/graphCreation.js

@@ -0,0 +1,43 @@
+import {Graph} from './DFS'
+import {
+    isSameSegment2D,
+  } from '@eturnity/eturnity_maths'
+export function generateGraph(polygons){
+    const edges2D=[]
+    const g=new Graph()
+    polygons
+      .filter((poly) => poly.layer=='roof')
+      .forEach((polygon,index) => {
+        g.dict.push(polygon.id)
+        const outline = polygon.outline
+        outline.forEach((point, i) => {
+          //check if edge2D already exist
+          const nextPoint = outline[(i + 1) % outline.length]
+          let edge2D = edges2D.find((edge) => {
+            return (
+              isSameSegment2D([point, nextPoint], edge.outline)
+            )
+          })
+          if (!edge2D) {
+            //create an edge at this position
+            edge2D = {}
+            edge2D.outline=[point, nextPoint]
+            edge2D.belongsTo = []
+            edges2D.push(edge2D)
+          }
+          //add BelongToPolygon
+          edge2D.belongsTo.push({
+            polygonId: polygon.id,
+            index: i,
+            polygon
+          })
+        })
+      })
+    for(let k in edges2D){
+        let edge=edges2D[k]
+        if(edge.belongsTo.length==2){
+            g.addEdge(edge.belongsTo[0].polygonId,edge.belongsTo[1].polygonId)
+        }
+    }  
+    return g
+}

package/src/helper/materials.js

@@ -0,0 +1,55 @@
+import * as THREE from 'three'
+import {beamColor,beamOpacity,node3DColor,node3dOpacity,defaultTextureUrls} from '../config'
+const material=[]
+
+material.wall = new THREE.MeshLambertMaterial({
+        color: 0xdddddd,
+        side:THREE.DoubleSide
+    })
+
+// TODO get Canvas image from TwoD
+material.obstacle = new THREE.MeshPhongMaterial({
+        color: 0xff0000,
+        side:THREE.DoubleSide,
+    })
+
+material.edge=new THREE.MeshPhongMaterial({ color: beamColor,transparent:true,opacity:beamOpacity })
+material.node=new THREE.PointsMaterial( { size: 0.05, sizeAttenuation: true,color: node3DColor, opacity:node3dOpacity, transparent: true } );
+    const loader = new THREE.TextureLoader()
+    // texture.minFilter = THREE.LinearFilter
+    material.panel={}
+    
+    for(let k=0;k<defaultTextureUrls.length;k++){
+        let texture=loader.load(defaultTextureUrls[k], function (texture) {})
+        material.panel['default_'+k] = new THREE.MeshBasicMaterial({
+            map: texture,
+            side: THREE.DoubleSide,
+        })
+    }
+
+material.flatRoof = new THREE.MeshPhongMaterial({
+        color: 0x00ff00,
+        specular: 0x009900,
+        shininess: 0,
+        flatShading: true,
+        side:THREE.DoubleSide,
+        transparent:true,
+        opacity:0.5
+    })
+
+material.moduleField = new THREE.MeshLambertMaterial({
+    color: 0xff0000,
+    side:THREE.DoubleSide,
+})    
+material.curvedRoof = new THREE.MeshPhongMaterial({
+        color: 0xffff00,
+        specular: 0x009900,
+        shininess: 0,
+        flatShading: true,
+        side:THREE.DoubleSide,
+        transparent:true,
+        opacity:0.5
+    })
+
+
+export {material}