@antv/l7-layers 2.9.19 → 2.9.22-alpha.0

package/lib/polygon/shaders/water/polygon_ocean_frag.glsl

@@ -0,0 +1,248 @@
+
+uniform float u_time: 0.0;
+uniform float u_opacity: 1.0;
+
+varying vec2 v_uv;
+varying mat4 styleMappingMat; // 传递从片元中传递的映射数据
+
+float coast2water_fadedepth = 0.10;
+float large_waveheight      = .750; // change to adjust the "heavy" waves
+float large_wavesize        = 3.4;  // factor to adjust the large wave size
+float small_waveheight      = 0.6;  // change to adjust the small random waves
+float small_wavesize        = 0.5;   // factor to ajust the small wave size
+float water_softlight_fact  = 15.;  // range [1..200] (should be << smaller than glossy-fact)
+float water_glossylight_fact= 120.; // range [1..200]
+float particle_amount       = 70.;
+// vec3 watercolor             = vec3(0.43, 0.60, 0.66); // 'transparent' low-water color (RGB)
+// vec3 watercolor2            = vec3(0.06, 0.07, 0.11); // deep-water color (RGB, should be darker than the low-water color)
+uniform vec4 u_watercolor;
+uniform vec4 u_watercolor2;
+vec3 water_specularcolor    = vec3(1.3, 1.3, 0.9);    // specular Color (RGB) of the water-highlights
+#define light                 vec3(-0., sin(u_time*0.5)*.5 + .35, 2.8) // position of the sun
+
+uniform sampler2D u_texture1;
+uniform sampler2D u_texture2;
+uniform sampler2D u_texture3;
+
+  
+
+float hash( float n ) {
+    return fract(sin(n)*43758.5453123);
+}
+
+// 2d noise function
+float noise1( in vec2 x ) {
+  vec2 p  = floor(x);
+  vec2 f  = smoothstep(0.0, 1.0, fract(x));
+  float n = p.x + p.y*57.0;
+  return mix(mix( hash(n+  0.0), hash(n+  1.0),f.x),
+    mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y);
+}
+
+float noise(vec2 p) {
+    return texture2D(u_texture2,p*vec2(1./256.)).x;
+}
+
+vec4 highness(vec2 p) {
+    vec4 t = texture2D(u_texture1,fract(p));
+    float clipped = -2.0-smoothstep(3.,10.,t.a)*6.9-smoothstep(10.,100.,t.a)*89.9-smoothstep(0.,10000.,t.a)*10000.0;
+    return clamp(t, 0.0,3.0)+clamp(t/3.0-1.0, 0.0,1.0)+clamp(t/16.0-1.0, 0.0,1.0);
+}
+
+float height_map( vec2 p ) {
+    vec4 height=highness(p);
+    /*
+    height = -0.5+
+        0.5*smoothstep(-100.,0.,-height)+
+        2.75*smoothstep(0.,2.,height)+
+        1.75*smoothstep(2.,4.,height)+
+        2.75*smoothstep(4.,16.,height)+
+        1.5*smoothstep(16.,1000.,height);
+    */
+
+    mat2 m = mat2( 0.9563*1.4,  -0.2924*1.4,  0.2924*1.4,  0.9563*1.4 );
+    //p = p*6.;
+    float f = 0.6000*noise1( p ); p = m*p*1.1*6.;
+    f += 0.2500*noise( p ); p = m*p*1.32;
+    f += 0.1666*noise( p ); p = m*p*1.11;
+    f += 0.0834*noise( p ); p = m*p*1.12;
+    f += 0.0634*noise( p ); p = m*p*1.13;
+    f += 0.0444*noise( p ); p = m*p*1.14;
+    f += 0.0274*noise( p ); p = m*p*1.15;
+    f += 0.0134*noise( p ); p = m*p*1.16;
+    f += 0.0104*noise( p ); p = m*p*1.17;
+    f += 0.0084*noise( p );
+    f = .25*f+dot(height,vec4(-.03125,-.125,.25,.25))*.5;
+        const float FLAT_LEVEL = 0.92525;
+        //f = f*0.25+height*0.75;
+    if (f<FLAT_LEVEL)
+        f = f;
+    else
+        f = pow((f-FLAT_LEVEL)/(1.-FLAT_LEVEL), 2.)*(1.-FLAT_LEVEL)*2.0+FLAT_LEVEL; // makes a smooth coast-increase
+    return clamp(f, 0., 10.);
+}
+
+vec3 plasma_quintic( float x ) {
+    x = clamp( x, 0.0, 1.0);
+    vec4 x1 = vec4( 1.0, x, x * x, x * x * x ); // 1 x x2 x3
+    vec4 x2 = x1 * x1.w * x; // x4 x5 x6 x7
+    return vec3(
+        dot( x1.xyzw, vec4( +0.063861086, +1.992659096, -1.023901152, -0.490832805 ) ) + dot( x2.xy, vec2( +1.308442123, -0.914547012 ) ),
+        dot( x1.xyzw, vec4( +0.049718590, -0.791144343, +2.892305078, +0.811726816 ) ) + dot( x2.xy, vec2( -4.686502417, +2.717794514 ) ),
+        dot( x1.xyzw, vec4( +0.513275779, +1.580255060, -5.164414457, +4.559573646 ) ) + dot( x2.xy, vec2( -1.916810682, +0.570638854 ) ) );
+}
+
+vec4 color(vec2 p){
+    vec4 c1 = vec4(1.7,1.6,.9,1);
+    vec4 c2 = vec4(.2,.94,.1,1);
+    vec4 c3 = vec4(.3,.2,.0,1);
+    vec4 c4 = vec4(.99,.99,1.6,1);
+    vec4 v = highness(p);
+    float los = smoothstep(0.1,1.1,v.b);
+    float his = smoothstep(3.5,6.5,v.b);
+    float ces = smoothstep(1.,5.,v.a);
+    vec4 lo = mix(c1,c2,los);
+    vec4 hi = mix(c3,c4,his);
+    vec4 ce = mix(lo,hi,ces);
+
+    return vec4(plasma_quintic(ces),1).ragb;
+}
+
+vec3 terrain_map( vec2 p )
+{
+  return color(p).rgb*0.75+0.25*vec3(0.7, .55, .4)+texture2D(u_texture3, fract(p*5.)).rgb*.5; // test-terrain is simply 'sandstone'
+}
+
+const mat2 m = mat2( 0.72, -1.60,  1.60,  0.72 );
+
+float water_map( vec2 p, float height ) {
+    vec2 p2 = p*large_wavesize;
+    vec2 shift1 = 0.001*vec2( u_time*160.0*2.0, u_time*120.0*2.0 );
+    vec2 shift2 = 0.001*vec2( u_time*190.0*2.0, -u_time*130.0*2.0 );
+
+    // coarse crossing 'ocean' waves...
+    float f = 0.6000*noise( p );
+    f += 0.2500*noise( p*m );
+    f += 0.1666*noise( p*m*m );
+    float wave = sin(p2.x*0.622+p2.y*0.622+shift2.x*4.269)*large_waveheight*f*height*height ;
+
+    p *= small_wavesize;
+    f = 0.;
+    float amp = 1.0, s = .5;
+    for (int i=0; i<9; i++)
+    { p = m*p*.947; f -= amp*abs(sin((noise( p+shift1*s )-.5)*2.)); amp = amp*.59; s*=-1.329; }
+    
+    return wave+f*small_waveheight;
+}
+
+float nautic(vec2 p) {
+    p *= 18.;
+    float f = 0.;
+    float amp = 1.0, s = .5;
+    for (int i=0; i<3; i++)
+    { p = m*p*1.2; f += amp*abs(smoothstep(0., 1., noise( p+u_time*s ))-.5); amp = amp*.5; s*=-1.227; }
+    return pow(1.-f, 5.);
+}
+
+float particles(vec2 p) {
+    p *= 200.;
+    float f = 0.;
+    float amp = 1.0, s = 1.5;
+    for (int i=0; i<3; i++)
+    { p = m*p*1.2; f += amp*noise( p+u_time*s ); amp = amp*.5; s*=-1.227; }
+    return pow(f*.35, 7.)*particle_amount;
+}
+
+float test_shadow( vec2 xy, float height) {
+    vec3 r0 = vec3(xy, height);
+    vec3 rd = normalize( light - r0 );
+    
+    float hit = 1.0;
+    float t   = 0.001;
+    for (int j=1; j<25; j++)
+    {
+        vec3 p = r0 + t*rd;
+        float h = height_map( p.xy );
+        float height_diff = p.z - h;
+        if (height_diff<0.0)
+        {
+            return 0.0;
+        }
+        t += 0.01+height_diff*.02;
+        hit = min(hit, 2.*height_diff/t); // soft shaddow   
+    }
+    return hit;
+}
+
+vec3 CalcTerrain(vec2 uv, float height) {
+    vec3 col = terrain_map( uv );
+    vec2 iResolution = vec2(512.);
+    float h1 = height_map(uv-vec2(0., 0.5)/ iResolution.xy);
+    float h2 = height_map(uv+vec2(0., 0.5)/ iResolution.xy);
+    float h3 = height_map(uv-vec2(0.5, 0.)/ iResolution.xy);
+    float h4 = height_map(uv+vec2(0.5, 0.)/ iResolution.xy);
+    vec3 norm = normalize(vec3(h3-h4, h1-h2, 1.));
+    vec3 r0 = vec3(uv, height);
+    vec3 rd = normalize( light - r0 );
+    float grad = dot(norm, rd);
+    col *= grad+pow(grad, 8.);
+    float terrainshade = test_shadow( uv, height );
+    col = mix(col*.25, col, terrainshade);
+    return col;
+}
+
+
+void main() {
+  vec3 watercolor = u_watercolor.rgb;
+  vec3 watercolor2 = u_watercolor2.rgb;
+  vec2 uv = v_uv;
+  float WATER_LEVEL = 0.84; // Water level (range: 0.0 - 2.0)
+  float deepwater_fadedepth   = 0.4 + coast2water_fadedepth;
+  float height = height_map( uv );
+  vec3 col;
+
+    float waveheight = clamp(WATER_LEVEL*3.-1.5, 0., 1.);
+    float level = WATER_LEVEL + .2*water_map(uv*15. + vec2(u_time*.1), waveheight);
+    if (height > level)
+    {
+        col = CalcTerrain(uv, height);
+    }
+    if (height <= level)
+    {
+        vec2 dif = vec2(.0, .01);
+        vec2 pos = uv*15. + vec2(u_time*.01);
+        float h1 = water_map(pos-dif,waveheight);
+        float h2 = water_map(pos+dif,waveheight);
+        float h3 = water_map(pos-dif.yx,waveheight);
+        float h4 = water_map(pos+dif.yx,waveheight);
+        vec3 normwater = normalize(vec3(h3-h4, h1-h2, .125)); // norm-vector of the 'bumpy' water-plane
+        uv += normwater.xy*.002*(level-height);
+        
+        col = CalcTerrain(uv, height);
+
+        float coastfade = clamp((level-height)/coast2water_fadedepth, 0., 1.);
+        float coastfade2= clamp((level-height)/deepwater_fadedepth, 0., 1.);
+        float intensity = col.r*.2126+col.g*.7152+col.b*.0722;
+        watercolor = mix(watercolor*intensity, watercolor2, smoothstep(0., 1., coastfade2));
+
+        vec3 r0 = vec3(uv, WATER_LEVEL);
+        vec3 rd = normalize( light - r0 ); // ray-direction to the light from water-position
+        float grad     = dot(normwater, rd); // dot-product of norm-vector and light-direction
+        float specular = pow(grad, water_softlight_fact);  // used for soft highlights                          
+        float specular2= pow(grad, water_glossylight_fact); // used for glossy highlights
+        float gradpos  = dot(vec3(0., 0., 1.), rd);
+        float specular1= smoothstep(0., 1., pow(gradpos, 5.));  // used for diffusity (some darker corona around light's specular reflections...)                          
+        float watershade  = test_shadow( uv, level );
+        watercolor *= 2.2+watershade;
+        watercolor += (.2+.8*watershade) * ((grad-1.0)*.5+specular) * .25;
+        watercolor /= (1.+specular1*1.25);
+        watercolor += watershade*specular2*water_specularcolor;
+        watercolor += watershade*coastfade*(1.-coastfade2)*(vec3(.5, .6, .7)*nautic(uv)+vec3(1., 1., 1.)*particles(uv));
+        
+        col = mix(col, watercolor, coastfade);
+    }
+    
+
+  float opacity = styleMappingMat[0][0];
+  gl_FragColor = vec4(col, opacity);  
+}

package/lib/polygon/shaders/water/polygon_ocean_vert.glsl

@@ -0,0 +1,52 @@
+attribute vec2 a_uv;
+attribute vec3 a_Position;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+varying vec2 v_uv;
+uniform float u_opacity: 1.0;
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#pragma include "styleMappingCalOpacity"
+
+#pragma include "projection"
+
+void main() {
+  v_uv = a_uv;
+  // cal style mapping - 数据纹理映射部分的计算
+styleMappingMat = mat4(
+    0.0, 0.0, 0.0, 0.0, // opacity - strokeOpacity - strokeWidth - empty
+    0.0, 0.0, 0.0, 0.0, // strokeR - strokeG - strokeB - strokeA
+    0.0, 0.0, 0.0, 0.0, // offsets[0] - offsets[1]
+    0.0, 0.0, 0.0, 0.0
+  );
+
+  float rowCount = u_cellTypeLayout[0][0];    // 当前的数据纹理有几行
+  float columnCount = u_cellTypeLayout[0][1]; // 当看到数据纹理有几列
+  float columnWidth = 1.0/columnCount;  // 列宽
+  float rowHeight = 1.0/rowCount;       // 行高
+  float cellCount = calCellCount(); // opacity - strokeOpacity - strokeWidth - stroke - offsets
+  float id = a_vertexId; // 第n个顶点
+  float cellCurrentRow = floor(id * cellCount / columnCount) + 1.0; // 起始点在第几行
+  float cellCurrentColumn = mod(id * cellCount, columnCount) + 1.0; // 起始点在第几列
+  
+  // cell 固定顺序 opacity -> strokeOpacity -> strokeWidth -> stroke ... 
+  // 按顺序从 cell 中取值、若没有则自动往下取值
+  float textureOffset = 0.0; // 在 cell 中取值的偏移量
+
+  vec2 opacityAndOffset = calOpacityAndOffset(cellCurrentRow, cellCurrentColumn, columnCount, textureOffset, columnWidth, rowHeight);
+  styleMappingMat[0][0] = opacityAndOffset.r;
+  textureOffset = opacityAndOffset.g;
+  // cal style mapping - 数据纹理映射部分的计算
+
+  vec4 project_pos = project_position(vec4(a_Position, 1.0));
+  // gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xyz, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+  }
+}
+

package/lib/polygon/shaders/water/polygon_water_frag.glsl

@@ -0,0 +1,73 @@
+uniform sampler2D u_texture;
+uniform float u_time: 0.0;
+uniform float u_speed: 1.0;
+uniform float u_opacity: 1.0;
+
+varying vec4 v_Color;
+varying vec2 v_uv;
+varying mat4 styleMappingMat; // 传递从片元中传递的映射数据
+
+
+float rand(vec2 n) { return 0.5 + 0.5 * fract(sin(dot(n.xy, vec2(12.9898, 78.233)))* 43758.5453); }
+
+float water(vec3 p) {
+  float t = u_time * u_speed;
+  p.z += t * 2.; p.x += t * 2.;
+  vec3 c1 = texture2D(u_texture, p.xz / 30.).xyz;
+  p.z += t * 3.; p.x += t * 0.52;
+  vec3 c2 = texture2D(u_texture, p.xz / 30.).xyz;
+  p.z += t * 4.; p.x += t * 0.8;
+  vec3 c3 = texture2D(u_texture, p.xz / 30.).xyz;
+  c1 += c2 - c3;
+  float z = (c1.x + c1.y + c1.z) / 3.;
+  return p.y + z / 4.;
+}
+
+float map(vec3 p) {
+  float d = 100.0;
+  d = water(p);
+  return d;
+}
+
+float intersect(vec3 ro, vec3 rd) {
+  float d = 0.0;
+  for (int i = 0; i <= 100; i++) {
+    float h = map(ro + rd * d);
+    if (h < 0.1) return  d;
+    d += h;
+  }
+  return 0.0;
+}
+
+vec3 norm(vec3 p) {
+  float eps = .1;
+  return normalize(vec3(
+    map(p + vec3(eps, 0, 0)) - map(p + vec3(-eps, 0, 0)),
+    map(p + vec3(0, eps, 0)) - map(p + vec3(0, -eps, 0)),
+    map(p + vec3(0, 0, eps)) - map(p + vec3(0, 0, -eps))
+  ));
+} 
+
+float calSpc() {
+  vec3 l1 = normalize(vec3(1, 1, 1));
+  vec3 ro = vec3(-3, 20, -8);
+  vec3 rc = vec3(0, 0, 0);
+  vec3 ww = normalize(rc - ro);
+  vec3 uu = normalize(cross(vec3(0,1,0), ww));
+  vec3 vv = normalize(cross(rc - ro, uu));
+  vec3 rd = normalize(uu * v_uv.x + vv * v_uv.y + ww);
+  float d = intersect(ro, rd);
+  vec3 p = ro + rd * d;
+  vec3 n = norm(p);
+  float spc = pow(max(0.0, dot(reflect(l1, n), rd)), 30.0);
+  return spc;
+}
+
+void main() {
+  float opacity = styleMappingMat[0][0];
+  gl_FragColor = v_Color;
+  gl_FragColor.a *= opacity;
+
+  float spc = calSpc();
+  gl_FragColor += spc * 0.4;
+}

package/lib/polygon/shaders/water/polygon_water_vert.glsl

@@ -0,0 +1,55 @@
+attribute vec4 a_Color;
+attribute vec2 a_uv;
+attribute vec3 a_Position;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+varying vec4 v_Color;
+varying vec2 v_uv;
+uniform float u_opacity: 1.0;
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#pragma include "styleMappingCalOpacity"
+
+#pragma include "projection"
+
+void main() {
+  v_uv = a_uv;
+  // cal style mapping - 数据纹理映射部分的计算
+styleMappingMat = mat4(
+    0.0, 0.0, 0.0, 0.0, // opacity - strokeOpacity - strokeWidth - empty
+    0.0, 0.0, 0.0, 0.0, // strokeR - strokeG - strokeB - strokeA
+    0.0, 0.0, 0.0, 0.0, // offsets[0] - offsets[1]
+    0.0, 0.0, 0.0, 0.0
+  );
+
+  float rowCount = u_cellTypeLayout[0][0];    // 当前的数据纹理有几行
+  float columnCount = u_cellTypeLayout[0][1]; // 当看到数据纹理有几列
+  float columnWidth = 1.0/columnCount;  // 列宽
+  float rowHeight = 1.0/rowCount;       // 行高
+  float cellCount = calCellCount(); // opacity - strokeOpacity - strokeWidth - stroke - offsets
+  float id = a_vertexId; // 第n个顶点
+  float cellCurrentRow = floor(id * cellCount / columnCount) + 1.0; // 起始点在第几行
+  float cellCurrentColumn = mod(id * cellCount, columnCount) + 1.0; // 起始点在第几列
+  
+  // cell 固定顺序 opacity -> strokeOpacity -> strokeWidth -> stroke ... 
+  // 按顺序从 cell 中取值、若没有则自动往下取值
+  float textureOffset = 0.0; // 在 cell 中取值的偏移量
+
+  vec2 opacityAndOffset = calOpacityAndOffset(cellCurrentRow, cellCurrentColumn, columnCount, textureOffset, columnWidth, rowHeight);
+  styleMappingMat[0][0] = opacityAndOffset.r;
+  textureOffset = opacityAndOffset.g;
+  // cal style mapping - 数据纹理映射部分的计算
+
+  v_Color = a_Color;
+  vec4 project_pos = project_position(vec4(a_Position, 1.0));
+  // gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xyz, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+  }
+}
+

package/lib/raster/buffers/triangulation.js

@@ -1,38 +1,51 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/raster/buffers/triangulation.ts
+var triangulation_exports = {};
+__export(triangulation_exports, {
+  RasterTriangulation: () => RasterTriangulation
 });
-exports.RasterTriangulation = RasterTriangulation;
-
-var _martini = _interopRequireDefault(require("@mapbox/martini"));
-
+module.exports = __toCommonJS(triangulation_exports);
+var import_martini = __toESM(require("@mapbox/martini"));
 function RasterTriangulation(parserData) {
-  var coordinates = parserData.coordinates,
-      data = parserData.data,
-      min = parserData.min,
-      max = parserData.max,
-      width = parserData.width,
-      height = parserData.height;
-  var maxlength = Math.max(width, height);
-  var gridSize = Math.pow(2, Math.ceil(Math.log2(maxlength))) + 1;
-  var terrain = new Float32Array(gridSize * gridSize);
-
-  for (var i = 0; i < width; i++) {
-    for (var j = 0; j < height; j++) {
+  const { coordinates, data, min, max, width, height } = parserData;
+  const maxlength = Math.max(width, height);
+  const gridSize = Math.pow(2, Math.ceil(Math.log2(maxlength))) + 1;
+  const terrain = new Float32Array(gridSize * gridSize);
+  for (let i = 0; i < width; i++) {
+    for (let j = 0; j < height; j++) {
       terrain[i * gridSize + j] = data[i * width + j];
     }
   }
-
-  var martini = new _martini.default(gridSize);
-  var tile = martini.createTile(terrain);
-  var mesh = tile.getMesh(gridSize / 2);
+  const martini = new import_martini.default(gridSize);
+  const tile = martini.createTile(terrain);
+  const mesh = tile.getMesh(gridSize / 2);
   return {
     vertices: Array.from(mesh.vertices),
     indices: Array.from(mesh.triangles),
     size: 2
   };
 }
-//# sourceMappingURL=triangulation.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RasterTriangulation
+});