@eturnity/eturnity_3d 8.16.0 → 8.16.2

package/src/helper/render/shadingMaterial/yearlySunShaderMaterial.js

@@ -0,0 +1,389 @@
+import * as THREE from 'three'
+import { getOptimizedGHI } from '@eturnity/eturnity_maths'
+export default class yearlySunShaderMaterial extends THREE.MeshPhysicalMaterial {
+  constructor(parameters) {
+    const {
+      lat,
+      lng,
+      dataGrids,
+      normalVector,
+      colorfull = true,
+      // Default grayscale colormap
+      colorMap = [
+        { value: 0, color: { r: 255, g: 255, b: 255 } },
+        { value: 1.0, color: { r: 0, g: 0, b: 0 } },
+      ],
+      isShadingFactor = false,
+      edges = [],
+      ...otherParameters
+    } = parameters
+    super(otherParameters)
+    this.normalVector = normalVector
+    this.MAX_EDGES_LENGTH = 500
+    this.needsUpdate = true
+    this.horizonResolution = this.dataGrids?.horizon?.length || 36
+    this.latitude = lat
+    this.longitude = lng
+    this.colorfull = colorfull
+    this.isShadingFactor = isShadingFactor
+    this.dataGrids = dataGrids
+    this.edges = edges
+    this.colorMap = [...colorMap].sort((a, b) => a.value - b.value)
+    let maxDNI = 0
+    this.dataGrids.dni_grid.forEach((dni_row) =>
+      dni_row.forEach((dni) => {
+        if (dni > maxDNI) {
+          maxDNI = dni
+        }
+      })
+    )
+    let maxDHI = 0
+    this.dataGrids.dhi_grid.forEach((dhi_row) =>
+      dhi_row.forEach((dhi) => (maxDHI = maxDHI > dhi ? maxDHI : dhi))
+    )
+    // Normalize DNI values using maxDNI
+    const normalizedDNIGrid = this.dataGrids.dni_grid.map((row) =>
+      row.map((dni) => dni / maxDNI)
+    )
+    const normalizedDHIGrid = this.dataGrids.dhi_grid.map((row) =>
+      row.map((dhi) => dhi / maxDHI)
+    )
+    const dniTexture = new THREE.DataTexture(
+      new Float32Array(normalizedDNIGrid.flat()),
+      this.dataGrids.dni_grid[0].length,
+      this.dataGrids.dni_grid.length,
+      THREE.RedFormat,
+      THREE.FloatType
+    )
+
+    const dhiTexture = new THREE.DataTexture(
+      new Float32Array(normalizedDHIGrid.flat()),
+      this.dataGrids.dhi_grid[0].length,
+      this.dataGrids.dhi_grid.length,
+      THREE.RedFormat,
+      THREE.FloatType
+    )
+
+    const horizonTexture = new THREE.DataTexture(
+      new Float32Array(this.dataGrids.horizon),
+      this.horizonResolution,
+      1,
+      THREE.RedFormat,
+      THREE.FloatType
+    )
+
+    dniTexture.needsUpdate = true
+    dhiTexture.needsUpdate = true
+    horizonTexture.needsUpdate = true
+
+    // Compute highest GHI
+    let highestGHI = getOptimizedGHI({
+      dataGrids: this.dataGrids,
+      lat,
+      lng,
+    })
+
+    const flattenedEdges = this.edges.flat().flatMap((v) => [v.x, v.y, v.z])
+
+    const stopValues = this.colorMap.map((stop) => stop.value)
+    const colorStops = this.colorMap
+      .map((stop) => {
+        const { r, g, b } = stop.color
+        return [r / 255, g / 255, b / 255]
+      })
+      .flat()
+
+    this.uniforms = {
+      gridsDNI: { value: dniTexture },
+      gridsDHI: { value: dhiTexture },
+      maxDNI: { value: maxDNI },
+      maxDHI: { value: maxDHI },
+      highestGHI: { value: highestGHI },
+      hasNormalVector: { value: this.normalVector ? 1 : 0 },
+      normalVector: {
+        value: this.normalVector ? this.normalVector : [0, 0, 0],
+      },
+      edges: { value: new Float32Array(flattenedEdges) },
+      horizon: { value: horizonTexture },
+      edgesLength: { value: this.edges.length },
+      colorfull: { value: this.colorfull ? 1 : 0 },
+      stopValues: { value: new Float32Array(stopValues) },
+      colorStops: {
+        value: new Float32Array(colorStops),
+      },
+      stopCount: { value: this.colorMap.length },
+      isShadingFactor: { value: this.isShadingFactor ? 1 : 0 },
+    }
+    this.count = 0
+    this.onBeforeCompile = this.onBeforeCompile.bind(this)
+  }
+  updateEdges(newEdges) {
+    if (newEdges.length == 0) {
+      newEdges = [
+        [
+          { x: 0, y: 0, z: 0 },
+          { x: 0, y: 0, z: 0 },
+        ],
+      ]
+    }
+    if (this.MAX_EDGES_LENGTH < newEdges.length) {
+      console.warn(
+        `Reduced edges from ${this.edges.length} to ${newEdges.length} to fit within MAX_EDGES_LENGTH (${this.MAX_EDGES_LENGTH})`
+      )
+    }
+    // Ensure we don't exceed MAX_EDGES_LENGTH
+    if (newEdges.length > this.MAX_EDGES_LENGTH) {
+      newEdges = newEdges.slice(0, this.MAX_EDGES_LENGTH)
+    }
+    this.edges = [...newEdges]
+    const flattenedEdges = newEdges.flat().flatMap((v) => [v.x, v.y, v.z])
+    this.uniforms.edges = { value: new Float32Array(flattenedEdges) }
+    this.uniforms.edgesLength = { value: newEdges.length }
+    this.needsUpdate = true
+    // Manually trigger recompilation
+  }
+  onBeforeCompile(shader) {
+    this.needsUpdate = true
+    Object.assign(this.uniforms, shader.uniforms)
+    shader.uniforms = this.uniforms
+    const flattenedEdges = this.edges.flat().flatMap((v) => [v.x, v.y, v.z])
+    shader.uniforms.edges = {
+      value: new Float32Array(flattenedEdges),
+    }
+    shader.uniforms.edgesLength = { value: this.edges.length }
+    this.compiledEdgesLength = this.edges.length
+    const vertexShader = `
+        varying vec4 vPosition;
+        varying vec2 screenPosition;
+        varying vec3 vNormal;
+        uniform int hasNormalVector;
+        uniform vec3 normalVector;
+        void main() {
+          vPosition = modelMatrix * vec4(position, 1.0);
+          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+          screenPosition = gl_Position.xy;
+          vNormal = normalize((modelMatrix * vec4(normal, 0.0)).xyz);
+          if(hasNormalVector == 1){
+            vNormal = normalize(normalVector);
+          }
+
+        }
+      `
+    const fragmentShader = `
+        uniform sampler2D gridsDNI;
+        uniform sampler2D gridsDHI;
+        uniform float maxDNI;
+        uniform float maxDHI;
+        uniform float highestGHI;
+        uniform vec3 edges[${this.MAX_EDGES_LENGTH * 2}];
+        uniform sampler2D horizon;
+        uniform int edgesLength;
+        uniform int colorfull;
+        uniform int isShadingFactor;
+        uniform int stopCount; 
+        uniform float stopValues[${this.colorMap.length}];
+        uniform vec3 colorStops[${this.colorMap.length}];
+        varying vec3 vNormal;
+        varying vec2 screenPosition;
+        varying vec4 vPosition;
+        int horizonResolution = ${this.horizonResolution};
+        float GROUND_ALBEDO = 0.2;
+
+        // Function to convert Cartesian to spherical coordinates
+        vec3 cartesianToSpherical(vec3 cartesian) {
+            float r = length(cartesian);
+            float cotheta = acos(cartesian.z / r);
+            float theta = 3.14159 / 2.0 - cotheta;
+            float phi = atan(cartesian.x, cartesian.y);
+            phi = mod(phi + 6.28318, 6.28318);
+            return vec3(r, theta, phi);
+        }
+        int getHorizonIndexFromPhiAngle(float phi) {
+            // Ensure phi is within [0, 2π]
+            phi = mod(phi, 6.28318);
+            
+            // Convert phi to degrees and scale to horizon resolution
+            float scaledPhi = (phi / (6.28318)) * float(horizonResolution);
+            
+            // Convert to integer and ensure it's within valid range
+            return clamp(int(scaledPhi), 0, horizonResolution - 1);
+        }
+        // Function to calculate the horizon from edges with resolution
+        void calculateHorizon(
+          out float horizonThetas[${this.horizonResolution}],
+          out float horizonMountainThetas[${this.horizonResolution}]
+        ) {
+            for (int i = 0; i < ${this.horizonResolution}; i++) {
+              float horizonValue = texture2D(horizon, vec2(float(i) / float(horizonResolution), 0.0)).r;
+              horizonThetas[i] = horizonValue;
+              horizonMountainThetas[i] = horizonValue;
+            }
+
+            for (int i = 0; i < ${this.MAX_EDGES_LENGTH}; i++) {
+                if (i > edgesLength) break;
+                vec3 edgeStart = cartesianToSpherical(edges[i*2] - vPosition.xyz);
+                vec3 edgeEnd = cartesianToSpherical(edges[i*2+1] - vPosition.xyz);
+                vec3 eStart=edges[i*2] - vPosition.xyz;
+                vec3 eEnd=edges[i*2 + 1] - vPosition.xyz;
+                bool flipEdges = false;
+                float phiDiff = mod(edgeEnd.z - edgeStart.z + 6.28318, 6.28318);
+                if (phiDiff > 3.14159) {
+                    flipEdges = true;
+                }
+                if(flipEdges){
+                    vec3 edgeTmp = edgeStart;
+                    edgeStart = edgeEnd;
+                    edgeEnd = edgeTmp;
+                    vec3 eTmp = eStart;
+                    eStart = eEnd;
+                    eEnd = eTmp;
+                }
+                int startPhiIndex = getHorizonIndexFromPhiAngle(edgeStart.z);
+                int endPhiIndex = getHorizonIndexFromPhiAngle(edgeEnd.z);
+                if(startPhiIndex > endPhiIndex){
+                    endPhiIndex += horizonResolution;
+                }
+                for (int j = startPhiIndex; j <= endPhiIndex; j++) {
+                    int index = j % horizonResolution;
+                    float phi = 2.0 * 3.14159 * float(index) / float(horizonResolution);
+                    vec3 u = eEnd - eStart;
+
+                    float denominator=u.x*cos(phi)-u.y*sin(phi);
+                    if(denominator==0.0){
+                        continue;
+                    }
+                    float numerator=eStart.y*sin(phi)-eStart.x*cos(phi);
+                    float t = numerator/denominator;
+                    if(t<0.0 || t>1.0){
+                        continue;
+                    }
+                    // Interpolate the Cartesian position
+                    vec3 interpolatedCartesian = mix(eStart, eEnd, t);
+                    // Convert interpolated Cartesian to spherical
+                    vec3 interpolatedSpherical = cartesianToSpherical(interpolatedCartesian);
+                    // Use the theta (y) component of the spherical coordinates
+                    float interpolatedTheta = interpolatedSpherical.y;
+                    horizonThetas[index] = max(horizonThetas[index], interpolatedTheta);
+                }
+            }
+        }
+
+        vec3 mapValueToColor(float value) {
+          for (int i = 0; i < stopCount; i++) {
+            float stop1 = stopValues[i];
+            float stop2 = stopValues[i + 1];
+
+            if (value >= stop1 && value <= stop2) {
+              float t = (value - stop1) / (stop2 - stop1);
+              return mix(colorStops[i], colorStops[i + 1], t);
+            }
+          }
+          return (value <= stopValues[0]) ? colorStops[0] : colorStops[stopCount - 1];
+        }
+        
+        void main() {
+          float plane_theta = acos(vNormal.z);
+          float plane_phi = atan(vNormal.x, vNormal.y);
+          plane_phi = mod(plane_phi + 6.28318, 6.28318);
+          
+          vec2 uv = vec2(
+            plane_phi / 6.28318, // Normalize phi to [0, 1]
+            plane_theta < 1.570795 ? 1.0-(plane_theta / 1.570795) : 0.0 // Normalize theta to [0, 1]
+          );
+          // Initialize sum
+          float totalGHI = 0.0;
+          
+          // Get resolution from texture size
+          vec2 resolution = vec2(1.0) / vec2(textureSize(gridsDNI, 0));
+          
+          // Calculate horizon with resolution
+          float horizonThetas[${this.horizonResolution}];
+          float horizonMountainThetas[${this.horizonResolution}];
+          calculateHorizon(horizonThetas, horizonMountainThetas);
+
+          // Loop through all possible sun positions
+          float enlightedArea = 0.0;
+          float enlightedAreaWithoutObstacles = 0.0;
+          float enlightedAreaWithoutHorizon = 0.0;
+          float referenceGHI = 0.0;
+          float totalDNIWithoutHorizon = 0.0;
+          float totalDNIWithoutObstacles = 0.0;
+          float totalDNI = 0.0;
+          float totalDHI = 0.0;
+          for (float phi = 0.0; phi <= 1.0; phi += resolution.x) {
+            for (float theta = 0.0; theta <= 1.0; theta += resolution.y) {
+              vec2 sunUV = vec2(phi, theta);
+              
+              // Sample DNI and DHI from textures
+              float dni = texture2D(gridsDNI, sunUV).r * maxDNI;
+              float dhi = texture2D(gridsDHI, sunUV).r * maxDHI;
+              
+              // Calculate sun direction vector
+              float phiRad = phi * 6.28318;
+              float thetaRad = theta * 1.57079;
+              vec3 sunDir = vec3(
+                cos(thetaRad) * sin(phiRad),
+                cos(thetaRad) * cos(phiRad),
+                sin(thetaRad)
+              );
+       
+              // Check if sun is blocked by the horizon
+              int phiIndex = getHorizonIndexFromPhiAngle(phiRad);
+              bool isBlocked = thetaRad <= horizonThetas[phiIndex];
+              bool isBlockedByMountain = thetaRad <= horizonMountainThetas[phiIndex];
+              
+              // Add to total GHI if not blocked
+              // Calculate cos_angle using normalVector
+              float cos_angle = max(dot(vNormal, sunDir), 0.0);
+              referenceGHI += dni * cos_angle + dhi;
+              totalDNIWithoutHorizon += dni * cos_angle;
+              if(cos_angle > 0.0){
+                if (!isBlocked) {
+                  totalDNI += dni * cos_angle;
+                  enlightedArea += 2.0 * cos(thetaRad) * sin(thetaRad) * pow((6.28318 * resolution.x) , 2.0);
+                }
+
+                if(!isBlockedByMountain) {
+                  totalDNIWithoutObstacles += dni * cos_angle;
+                  enlightedAreaWithoutObstacles += 2.0 * cos(thetaRad) * sin(thetaRad) * pow((6.28318 * resolution.x) , 2.0);
+                }
+                enlightedAreaWithoutHorizon += 2.0 * cos(thetaRad) * sin(thetaRad) * pow((6.28318 * resolution.x) , 2.0);
+              }
+
+              //compute of Ineichen diffuse
+              float F = 1.0 - pow(dhi / max(dni * cos_angle + dhi, 1e-6), 2.0);
+              float diffusion_Ineichen = dhi * (1.0 + cos(plane_theta) / 2.0) * 
+                                         (1.0 + F * pow(sin(plane_theta / 2.0), 3.0)) * 
+                                         (1.0 + F * pow(cos_angle, 2.0) * pow(cos(thetaRad), 3.0));
+              totalDHI += diffusion_Ineichen;
+            }
+          }
+          float ground_reflection = GROUND_ALBEDO * referenceGHI * (1.0 - cos(plane_theta)) / 2.0;
+          totalGHI = totalDNI + totalDHI * (enlightedArea / enlightedAreaWithoutHorizon) + ground_reflection;
+          float totalGHIWithoutHorizon = totalDNIWithoutHorizon + totalDHI + ground_reflection;
+
+          float totalDHIWithoutObstacles = totalDHI * (enlightedAreaWithoutObstacles / enlightedAreaWithoutHorizon);
+          float totalGHIWithoutObstacles = totalDNIWithoutObstacles + totalDHIWithoutObstacles + ground_reflection;
+          
+          // Normalize the total for visualization
+          float result = 0.0;
+
+          if(isShadingFactor == 1) {
+            result = 1.0 - (totalGHI / totalGHIWithoutObstacles);
+          } else {
+            result = totalGHI / (highestGHI);
+          }
+          
+          vec3 color;
+          if (colorfull == 0) {
+            color = vec3(result, result, result);
+          } else {
+            color = mapValueToColor(result);
+          }
+          gl_FragColor = vec4(color, 1.0);
+        }
+      `
+    shader.vertexShader = vertexShader
+    shader.fragmentShader = fragmentShader
+  }
+}

package/src/helper/renderMixin.js

@@ -159,6 +159,16 @@ export default {
             method: this.renderEdges,
             arg: [],
           })
+          methodList.push({
+            name: 'renderOverlays',
+            method: this.renderOverlays,
+            arg: [],
+          })
+          methodList.push({
+            name: 'updateProjectionMaterials',
+            method: this.updateProjectionMaterials,
+            arg: [],
+          })
         case 'marginIsSameChange': //params.polygon
         case 'marginDifferentChange': //params.polygon,index
         case 'marginSameChange': //params.polygon
@@ -410,6 +420,13 @@ export default {
             arg: [],
           })
           break
+        case 'updateIsYearlyShadingHeatmapActive':
+          methodList.push({
+            name: 'setModuleFieldsVisibility',
+            method: this.setModuleFieldsVisibility,
+            arg: [!params.value],
+          })
+          break
         case 'selectedPanelChange':
           methodList.push({
             name: 'renderModuleFields',