deeptwins-engine-3d 0.1.65 → 0.1.67

package/dist/esm/material/shader/AtmosphericShader.glsl

@@ -0,0 +1,244 @@
+precision highp float;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+uniform float u_threshold;
+uniform float u_blendFactor;
+uniform float u_lightIntensity;
+uniform float u_scatterStrength;
+uniform float u_tonemapExposure;
+uniform float u_mieExtinctionStrength;
+uniform float u_fogOpacity;
+uniform float u_fogPower;
+uniform float u_clearMixBias;
+in vec2 v_textureCoordinates;
+const float PI = 3.14159265359;
+const float TWO_PI = PI * 2.0;
+const float FOUR_PI = PI * 4.0;
+const float SCATTER_VISIBILITY_SCALE = 30000.0;
+const float MAX_EXPOSURE_RESPONSE = 1.8;
+const float MAX_LIGHT_RESPONSE = 3.0;
+
+const vec3 betaR = vec3(5.5e-6, 13.0e-6, 22.4e-6);
+
+const vec3 betaM = vec3(21e-6);
+
+const float hR = 10e3;
+const float hM = 3.8e3;
+const int num_samples = 16;
+const int num_samples_light = 4;
+#ifdef GL_ES
+          #define _in(T) const in T
+          #define _inout(T) inout T
+          #define _out(T) out T
+          #define _begin(type) type (
+          #define _end )
+          #define mul(a, b) (a) * (b)
+      #endif
+
+struct ray_t {
+    vec3 origin;
+    vec3 direction;
+};
+struct sphere_t {
+    vec3 origin;
+    float radius;
+    int material;
+};
+struct plane_t {
+    vec3 direction;
+    float distance;
+    int material;
+};
+plane_t plane;
+mat3 rotate_around_x(_in(float)  angle_degrees) {
+    float angle = radians(angle_degrees);
+    float _sin = sin(angle);
+    float _cos = cos(angle);
+    return mat3(1, 0, 0, 0, _cos, -_sin, 0, _sin, _cos);
+}
+
+bool isect_sphere(_in(ray_t)  ray, _in(sphere_t)  sphere, _inout(float)  t0, _inout(float)  t1) {
+    vec3 rc = sphere.origin - ray.origin;
+    float radius2 = sphere.radius * sphere.radius;
+    float tca = dot(rc, ray.direction);
+    float d2 = dot(rc, rc) - tca * tca;
+    if (d2 > radius2) return false;
+    float thc = sqrt(radius2 - d2);
+    t0 = tca - thc;
+    t1 = tca + thc;
+    return true;
+}
+float rayleigh_phase_func(float mu) {
+    return
+    3. * (1. + mu * mu)
+    /
+    (16. * PI);
+}
+const float g = 0.76;
+float henyey_greenstein_phase_func(float mu) {
+    return
+    (1. - g * g)
+    /
+    ((4. * PI) * pow(1. + g * g - 2. * g * mu, 1.5));
+}
+const float k = 1.55 * g - 0.55 * (g * g * g);
+float schlick_phase_func(float mu) {
+    return
+    (1. - k * k)
+    /
+    (4. * PI * (1. + k * mu) * (1. + k * mu));
+}
+const sphere_t atmosphere = _begin(sphere_t)
+vec3(0, 0, 0), 6420e3, 0
+_end;
+
+bool get_sun_light(
+_in(ray_t)  ray, _inout(float)  optical_depthR, _inout(float)  optical_depthM
+) {
+    float t0, t1;
+    isect_sphere(ray, atmosphere, t0, t1);
+    float march_pos = 0.;
+    float march_step = t1 / float(num_samples_light);
+    for (int i = 0; i < num_samples_light; i++) {
+        vec3 s = ray.origin +
+        ray.direction * (march_pos + 0.5 * march_step);
+        float height = length(s) - 6360e3;
+        if (height < 0.)
+        return false;
+        optical_depthR += exp(-height / hR) * march_step;
+        optical_depthM += exp(-height / hM) * march_step;
+        march_pos += march_step;
+    }
+    return true;
+}
+vec4 get_incident_light(_in(ray_t)  ray) {
+    vec3 dir = ray.direction;
+    vec3 start = ray.origin;
+    float a = dot(dir, dir);
+    float b = 2.0 * dot(dir, start);
+    float radius2 = atmosphere.radius * atmosphere.radius;
+    float c = dot(start, start) - radius2;
+    float d = (b * b) - 4.0 * a * c;
+    if (d < 0.0) return vec4(0.0);
+    float squaredD = sqrt(d);
+    vec2 ray_length = vec2(
+    max((-b - squaredD) / (2.0 * a), 0.0), min((-b + squaredD) / (2.0 * a), plane.distance)
+    );
+    if (ray_length.x > ray_length.y) return vec4(0.0);
+    float march_step = (ray_length.y - ray_length.x) / float(num_samples);
+    float mu = dot(ray.direction, normalize(czm_sunPositionWC));
+    float phaseR = rayleigh_phase_func(mu);
+    float phaseM =
+    #if 1
+              henyey_greenstein_phase_func(mu);
+    #else
+              schlick_phase_func(mu);
+    #endif
+
+    float optical_depthR = 0.;
+    float optical_depthM = 0.;
+    vec3 sumR = vec3(0);
+    vec3 sumM = vec3(0);
+    float march_pos = 0.;
+    for (int i = 0; i < num_samples; i++) {
+        vec3 s = ray.origin +
+        ray.direction * (march_pos + 0.5 * march_step);
+        float height = length(s) - 6360e3;
+
+        float hr = exp(-height / hR) * march_step;
+        float hm = exp(-height / hM) * march_step;
+        optical_depthR += hr;
+        optical_depthM += hm;
+
+        ray_t light_ray = _begin(ray_t)
+        s, normalize(czm_sunPositionWC)
+        _end;
+        float optical_depth_lightR = 0.;
+        float optical_depth_lightM = 0.;
+        bool overground = get_sun_light(
+            light_ray,
+            optical_depth_lightR,
+            optical_depth_lightM);
+
+        if (overground) {
+
+            vec3 tau =
+            betaR * (optical_depthR + optical_depth_lightR) +
+            betaM * u_mieExtinctionStrength * (optical_depthM + optical_depth_lightM);
+            vec3 attenuation = exp(-tau);
+            sumR += hr * attenuation;
+            sumM += hm * attenuation;
+        }
+
+        march_pos += march_step;
+    }
+    vec3 transmittance = exp(-((betaM * optical_depthM * u_mieExtinctionStrength)
+    + (betaR * optical_depthR)) * 4.);
+    float attenuation = clamp(dot(transmittance, vec3(0.3333333)), 0.0, 1.0);
+
+    return vec4(
+    u_scatterStrength *
+    (sumR * phaseR * betaR +
+    sumM * phaseM * betaM), 1.0 - attenuation);
+}
+
+void main() {
+    vec4 rawColor = texture(colorTexture, v_textureCoordinates);
+    float depth = czm_unpackDepth(texture(depthTexture, v_textureCoordinates));
+
+    vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord.xy, depth);
+    vec4 positionWC = czm_inverseView * positionEC;
+    positionWC.xyz = positionWC.xyz / positionWC.w;
+
+    vec3 lVector = positionWC.xyz - czm_viewerPositionWC;
+    ray_t ray;
+    ray.origin = czm_viewerPositionWC;
+    ray.direction = normalize(lVector);
+    plane.distance = length(lVector);
+
+    vec4 atmosphereColor = get_incident_light(ray);
+    float lightControl = clamp(u_lightIntensity / 4.0, 0.0, 1.0);
+    float lightStrength = MAX_LIGHT_RESPONSE * (
+    1.0 - exp(-2.6 * pow(lightControl, 1.6))
+    );
+    vec3 scatterColor = atmosphereColor.rgb * lightStrength;
+    float exposureControl = clamp(u_tonemapExposure / 3.0, 0.0, 1.0);
+    float exposureStrength = pow(exposureControl, 1.25) * MAX_EXPOSURE_RESPONSE;
+    float mieVisualFactor = mix(
+        0.6,
+        1.8,
+        clamp(u_mieExtinctionStrength / 2.0, 0.0, 1.0)
+    );
+    vec3 visibleScatter = 1.0 - exp(
+        -max(scatterColor * SCATTER_VISIBILITY_SCALE, 0.0) * exposureStrength
+    );
+    visibleScatter *= mieVisualFactor;
+    float brightness = dot(visibleScatter, vec3(0.299, 0.587, 0.114));
+    float thresholdMask = u_threshold > 0.0
+    ? smoothstep(0.0, u_threshold, brightness)
+    : 1.0;
+    visibleScatter *= thresholdMask;
+    float fogSignal = clamp(atmosphereColor.a * 2.5, 0.0, 1.0);
+    float fogAlpha = clamp(
+        pow(fogSignal, u_fogPower) * u_fogOpacity * mieVisualFactor,
+        0.0,
+        1.0
+    );
+    float clearPreserve = clamp(1.0 - u_clearMixBias, 0.0, 1.0);
+    float fogMix = fogAlpha * clearPreserve * 0.85;
+    vec3 foggedBase = mix(
+        rawColor.rgb,
+        rawColor.rgb * (1.0 - fogAlpha * 0.35),
+        fogMix
+    );
+    vec3 overlayColor = visibleScatter *
+    (0.55 + fogAlpha * 1.25) *
+    mix(1.0, 0.6, u_clearMixBias);
+    vec3 finalColor = mix(
+        rawColor.rgb,
+        foggedBase + overlayColor,
+        u_blendFactor
+    );
+
+    out_FragColor = vec4(clamp(finalColor, 0.0, 1.0), rawColor.a);
+}

package/dist/esm/material/shader/RainShader.glsl

@@ -4,6 +4,10 @@ uniform sampler2D colorTexture;
 uniform float direction;
 uniform float size;
 uniform float speed;
+uniform float density;
+uniform float opacity;
+uniform float gloominess;
+uniform vec4 rainColor;
 in vec2 v_textureCoordinates;
 out vec4 fragColor;
 
@@ -11,18 +15,52 @@ float hash(float x) {
     return fract(sin(x * 133.3) * 13.13);
 }
 
+float rainLayer(vec2 uv, float time, float densityFactor, float scaleFactor, float seed) {
+    vec2 warpedUv = uv;
+    warpedUv *= scaleFactor;
+
+    float v = 1.0 - sin(hash(floor((warpedUv.x + seed) * 100.0 * densityFactor)) * 2.0);
+    float b = clamp(
+        abs(sin((20.0 + seed * 2.5) * time * v + warpedUv.y * (5.0 / (2.0 + v)))) - 0.95,
+        0.0,
+        1.0
+    ) * (18.0 + densityFactor * 2.0);
+
+    return v * b;
+}
+
+vec3 applyGloominess(vec3 sceneColor) {
+    float gloomFactor = clamp(gloominess, 0.0, 1.0);
+    float luminance = dot(sceneColor, vec3(0.299, 0.587, 0.114));
+    vec3 mutedScene = mix(sceneColor, vec3(luminance), gloomFactor * 0.45);
+    return mutedScene * (1.0 - gloomFactor * 0.55);
+}
+
 void main() {
     float time = czm_frameNumber / speed;
     vec2 resolution = czm_viewport.zw;
     vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
-    vec3 c = vec3(0.6, 0.7, 0.8);
     float a = direction;
     float si = sin(a), co = cos(a);
     uv *= mat2(co, -si, si, co);
-    uv *= length(uv + vec2(0.0, 4.9)) * size + 1.0;
-    float v = 1.0 - sin(hash(floor(uv.x * 100.0)) * 2.0);
-    float b = clamp(abs(sin(20.0 * time * v + uv.y * (5.0 / (2.0 + v)))) - 0.95, 0.0, 1.0) * 20.0;
-    c *= v * b;
 
-    fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(c, 1.0), 0.5);
+    vec2 primaryUv = uv;
+    primaryUv *= length(primaryUv + vec2(0.0, 4.9)) * size + 1.0;
+
+    float densityFactor = mix(0.65, 2.1, clamp(density / 100.0, 0.0, 1.0));
+    float primaryLayer = rainLayer(primaryUv, time, densityFactor, 1.0, 0.0);
+
+    vec2 secondaryUv = primaryUv * 1.35;
+    secondaryUv.x += time * 0.25;
+    secondaryUv.y += hash(floor(primaryUv.x * 8.0) + 17.0) * 0.75;
+    float secondaryLayer = rainLayer(secondaryUv, time * 1.15, densityFactor * 0.85, 1.0, 3.7) * 0.65;
+
+    float rainMask = clamp(primaryLayer + secondaryLayer, 0.0, 1.0);
+
+    vec4 scene = texture(colorTexture, v_textureCoordinates);
+    vec3 baseScene = applyGloominess(scene.rgb);
+    vec3 rainLayerColor = rainColor.rgb * rainMask * opacity;
+    vec3 finalColor = clamp(baseScene + rainLayerColor, 0.0, 1.0);
+
+    fragColor = vec4(finalColor, scene.a);
 }

package/dist/esm/material/shader/lightning.glsl

@@ -0,0 +1,70 @@
+precision highp float;
+
+float hash(float x)
+{
+  return fract(21654.6512 * sin(385.51 * x));
+}
+float hash(vec2 p)
+{
+  return fract(1654.65157 * sin(15.5134763 * p.x + 45.5173247 * p.y + 5.21789));
+}
+vec2 hash2(vec2 p)
+{
+  return vec2(hash(p * .754), hash(1.5743 * p + 4.5476351));
+}
+const vec2 hashAdd = vec2(1.0, 0.0);
+vec2 noise2(vec2 x)
+{
+  vec2 p = floor(x);
+  vec2 f = fract(x);
+  f = f * f * (3.0 - 2.0 * f);
+  vec2 res = mix(mix(hash2(p),
+  hash2(p + hashAdd.xy), f.x),
+  mix(hash2(p + hashAdd.yx), hash2(p + hashAdd.xx), f.x), f.y);
+  return res;
+}
+vec2 fbm2(vec2 x)
+{
+  vec2 r = vec2(0.0);
+  float a = 1.0;
+  for (int i = 0; i < 8; i++)
+  {
+    r += noise2(x) * a;
+    x *= 2.;
+    a *= .5;
+  }
+  return r;
+}
+float dseg(vec2 ba, vec2 pa)
+{
+  float h = clamp(dot(pa, ba) / dot(ba, ba), -0.2, 1.);
+  return length(pa - ba * h);
+}
+uniform sampler2D colorTexture;
+uniform float fall_interval;
+uniform float mix_factor;
+in vec2 v_textureCoordinates;
+out vec4 fragColor;
+void main(void){
+  float iTime = czm_frameNumber * fall_interval * clamp(fall_interval * 0.1, 0.01, 0.1);
+  vec2 p = gl_FragCoord.xy / czm_viewport.zw;
+  vec2 d;
+  vec2 tgt = vec2(1., -1.);
+  vec3 col = vec3(0.);
+  float mdist = 100000.;
+  float t = hash(floor(5. * iTime));
+  tgt += 4. * hash2(tgt + t) - 1.5;
+  if (hash(t + 2.3) > .6)
+  for (int i = 0; i < 100; i++) {
+    vec2 dtgt = tgt - p;
+    d = .05 * (vec2(-.5, -1.) + hash2(vec2(float(i), t)));
+    float dist = dseg(d, dtgt);
+    mdist = min(mdist, dist);
+    tgt -= d;
+    float bolt = exp(-1.2 * dist) + exp(-55. * mdist);
+    col = max(col, bolt * vec3(.7, .8, 1.));
+  }
+  vec4 scene = texture(colorTexture, v_textureCoordinates);
+  vec3 finalColor = clamp(scene.rgb + col * mix_factor, 0.0, 1.0);
+  fragColor = vec4(finalColor, scene.a);
+}

package/dist/esm/measure/BaseDraw.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import { type Cartesian2, type Cartesian3 } from 'deeptwins-cesium';
 import { MeasureContext, MeasureDrawConfig, MeasureLabelLayer, MeasureMap, MeasurePosition, ResolvedMeasureConfig } from './types';
 declare class BaseDraw {

package/dist/esm/measure/types.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import type { Viewer } from 'deeptwins-cesium';
 import type Drawer from '../drawer';
 export declare const MEASURE_TYPE: {

package/dist/esm/measure/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import { MultiPolygon, Polygon } from '@turf/helpers';
 import { Cartesian2, Cartesian3, type Viewer } from 'deeptwins-cesium';
 /**