deeptwins-engine-3d 0.1.65 → 0.1.66

package/dist/esm/material/entity/ImageMaterialProperty.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="deepteins-engine-3d/typings" />
 import * as Cesium from 'deeptwins-cesium';
 export default class ImageMaterialProperty extends Cesium.ImageMaterialProperty {
     constructor(options: any);

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/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';
 /**