代码
var CENTER = new BMap.Point(106.512, 29.604);

var map = new BMap.Map('map', {enableAdaptiveMinZoom: false, backgroundColor: [6, 19, 32, 255]});
map.centerAndZoom(CENTER, 14);
map.setTilt(50);
map.enableScrollWheelZoom(true);
// 深色底图,关闭所有文字、POI 图标和路牌
map.setMapStyle({
  styleJson: [
    {featureType: 'land', elementType: 'geometry', stylers: {color: '#0b1b2bff'}},
    {featureType: 'water', elementType: 'geometry', stylers: {color: '#061320ff'}},
    {featureType: 'green', elementType: 'geometry', stylers: {color: '#0e2334ff'}},
    {featureType: 'building', elementType: 'geometry', stylers: {color: '#12293dff'}},
    {featureType: 'manmade', elementType: 'geometry', stylers: {color: '#0e2132ff'}},
    {featureType: 'road', elementType: 'geometry.fill', stylers: {color: '#15304aff'}},
    {featureType: 'road', elementType: 'geometry.stroke', stylers: {color: '#0b1b2bff'}},
    {featureType: 'railway', elementType: 'geometry', stylers: {visibility: 'off'}},
    {featureType: 'subway', elementType: 'geometry', stylers: {visibility: 'off'}},
    {featureType: 'all', elementType: 'labels', stylers: {visibility: 'off'}},
    {featureType: 'all', elementType: 'labels.icon', stylers: {visibility: 'off'}},
    {featureType: 'road', elementType: 'labels', stylers: {visibility: 'off'}},
    {featureType: 'road', elementType: 'labels.icon', stylers: {visibility: 'off'}},
    {featureType: 'poilabel', elementType: 'all', stylers: {visibility: 'off'}},
  ],
});

// ================= 彩虹路线 =================
// 折点按顺序依次取一个颜色,颜色在折点之间渐变;线上每隔一段画一个白色箭头
var ROUTE = [
  [106.46511017225053, 29.57895992140978],
  [106.47775831382684, 29.588508247138453],
  [106.47933933152389, 29.5964226147607],
  [106.48825052217992, 29.609109418994105],
  [106.51239697428015, 29.617650121451547],
  [106.52030206276535, 29.61802690031047],
  [106.5351061375649, 29.621920198526308],
  [106.53970546177446, 29.620915490952946],
  [106.54487970151023, 29.62392958331314],
  [106.55839021637583, 29.626064510293723],
];
var ROUTE_COLORS = ['#f00', '#f0f', '#0af', '#0a0', '#f09', '#a09', '#ff0', '#fd0', '#f90', '#f00'];

var ROUTE_VS = [
  'attribute vec2 a_pos;',
  'attribute vec2 a_offset;', // 已乘左右侧符号的斜接方向,长度 = 斜接长度 / 半宽
  'attribute vec3 a_color;',
  'attribute vec2 a_info;', // x:沿线累计长度(米),y:-1 左侧 / 1 右侧
  'uniform mat4 u_mvpMatrix;',
  'uniform float u_unitsPerPixel;',
  'uniform float u_halfWidth;',
  'varying vec3 v_color;',
  'varying vec2 v_info;',
  'void main() {',
  '    v_color = a_color;',
  '    v_info = a_info;',
  // 按「像素 × 每像素米数」外扩,缩放时线宽在屏幕上不变
  '    vec2 p = a_pos + a_offset * u_halfWidth * u_unitsPerPixel;',
  '    gl_Position = u_mvpMatrix * vec4(p, 0.0, 1.0);',
  '}',
].join('\n');

var ROUTE_FS = [
  'precision highp float;',
  'uniform float u_opacity;',
  'uniform float u_unitsPerPixel;',
  'uniform float u_halfWidth;',
  'uniform float u_arrowGap;', // 箭头间距,CSS 像素
  'varying vec3 v_color;',
  'varying vec2 v_info;',
  'void main() {',
  // 换到屏幕像素:沿线方向 x 以箭头为中心,横向 s 是到中线的距离
  '    float x = mod(v_info.x / u_unitsPerPixel, u_arrowGap) - u_arrowGap * 0.5;',
  '    float s = abs(v_info.y) * u_halfWidth;',
  // 「>」形箭头:越靠两侧越往后错,尖朝前进方向
  '    float d = x + s;',
  '    float arrow = step(0.0, d) * step(d, 3.5) * step(s, u_halfWidth * 0.7);',
  '    gl_FragColor = vec4(mix(v_color, vec3(1.0), arrow), u_opacity);',
  '}',
].join('\n');

function hexToRGB(hex) {
  var h = hex.replace('#', '');
  if (h.length === 3) {
    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
  }
  var n = parseInt(h, 16);
  return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];
}

/**
 * 折线挤出成带斜接拐角的条带:每个折点左右各一个顶点,拐角处按两段法线的角平分线外扩。
 *
 * @param {Object} layer 用它的 projectToLayer 换算局部坐标
 * @param {Array} path [[lng, lat], ...]
 * @param {Array<string>} colors 依次分给各折点的颜色
 * @return {Object} {attributes, indices}
 */
function buildRoute(layer, path, colors) {
  var xy = layer.projectToLayer(path);
  var n = xy.length;
  var normals = [];
  for (var i = 0; i < n - 1; i++) {
    var dx = xy[i + 1][0] - xy[i][0];
    var dy = xy[i + 1][1] - xy[i][1];
    var len = Math.sqrt(dx * dx + dy * dy) || 1;
    normals.push([-dy / len, dx / len]);
  }
  var pos = [];
  var offset = [];
  var color = [];
  var info = [];
  var indices = [];
  var dist = 0;
  for (i = 0; i < n; i++) {
    if (i > 0) {
      dist += Math.sqrt(
        Math.pow(xy[i][0] - xy[i - 1][0], 2) + Math.pow(xy[i][1] - xy[i - 1][1], 2),
      );
    }
    var a = normals[Math.max(0, i - 1)];
    var b = normals[Math.min(n - 2, i)];
    var mx = a[0] + b[0];
    var my = a[1] + b[1];
    var ml = Math.sqrt(mx * mx + my * my) || 1;
    mx /= ml;
    my /= ml;
    // 斜接长度 = 1 / cos(半角);急弯时会无限长,钳到 3 倍半宽
    var scale = Math.min(3, 1 / Math.max(1e-3, mx * b[0] + my * b[1]));
    var rgb = hexToRGB(colors[i % colors.length]);
    for (var side = -1; side <= 1; side += 2) {
      pos.push(xy[i][0], xy[i][1]);
      offset.push(mx * scale * side, my * scale * side);
      color.push(rgb[0], rgb[1], rgb[2]);
      info.push(dist, side);
    }
    if (i < n - 1) {
      var k = i * 2;
      indices.push(k, k + 1, k + 2, k + 1, k + 3, k + 2);
    }
  }
  return {
    attributes: {
      a_pos: {data: new Float32Array(pos), size: 2},
      a_offset: {data: new Float32Array(offset), size: 2},
      a_color: {data: new Float32Array(color), size: 3},
      a_info: {data: new Float32Array(info), size: 2},
    },
    indices: indices,
  };
}

var routeLayer = new BMap.WebGLCustomLayer({
  referCenter: CENTER,
  zIndex: 1,
  vertexShader: ROUTE_VS,
  fragmentShader: ROUTE_FS,
  uniforms: {u_halfWidth: 7.5, u_arrowGap: 120},
  draw: {mode: 'TRIANGLES'},
});
var route = buildRoute(routeLayer, ROUTE, ROUTE_COLORS);
routeLayer.setAttributes(route.attributes);
routeLayer.setIndices(route.indices);
map.addLayer(routeLayer);

// ================= 涟漪 =================
// 每个点一张屏幕对齐的 gl_Point,片元里按 u_time 画两圈往外扩、边扩边淡的波
var RIPPLE_POINTS = [
  [106.4785, 29.5885],
  [106.4883, 29.6091],
  [106.5124, 29.6177],
  [106.5351, 29.6219],
  [106.5584, 29.6261],
  [106.505, 29.59],
];

var RIPPLE_VS = [
  'attribute vec2 a_pos;',
  'attribute float a_phase;', // 每个点的起始相位,涟漪就不会齐步走
  'uniform mat4 u_mvpMatrix;',
  'uniform float u_pixelRatio;',
  'uniform float u_size;', // 涟漪最大直径,CSS 像素
  'varying float v_phase;',
  'void main() {',
  '    v_phase = a_phase;',
  '    gl_Position = u_mvpMatrix * vec4(a_pos, 0.0, 1.0);',
  '    gl_PointSize = u_size * u_pixelRatio;',
  '}',
].join('\n');

var RIPPLE_FS = [
  'precision mediump float;',
  'uniform float u_opacity;',
  'uniform float u_time;',
  'uniform float u_duration;',
  'uniform vec3 u_color;',
  'varying float v_phase;',
  'const int WAVES = 2;',
  'void main() {',
  '    float r = length(gl_PointCoord - 0.5) * 2.0;',
  '    if (r > 1.0) { discard; }',
  '    float p = fract(u_time / u_duration + v_phase);',
  '    float a = 0.0;',
  '    for (int i = 0; i < WAVES; i++) {',
  // 第 i 圈波当前扩到的半径 ri(0~1),越往外越淡
  '        float ri = fract(p + float(i) / float(WAVES));',
  '        float fade = 1.0 - ri;',
  '        float fill = step(r, ri) * 0.3;',
  '        float edge = 1.0 - smoothstep(0.0, 0.06, abs(r - ri));',
  '        a += (fill + edge) * fade;',
  '    }',
  '    gl_FragColor = vec4(u_color, min(a, 1.0) * u_opacity);',
  '}',
].join('\n');

var rippleLayer = new BMap.WebGLCustomLayer({
  referCenter: CENTER,
  zIndex: 2,
  vertexShader: RIPPLE_VS,
  fragmentShader: RIPPLE_FS,
  uniforms: {u_size: 80, u_duration: 3, u_color: [1, 0.2, 0]},
  animation: true,
  draw: {mode: 'POINTS'},
});
var ripplePhase = [];
for (var ri = 0; ri < RIPPLE_POINTS.length; ri++) {
  ripplePhase.push(Math.random());
}
rippleLayer.setAttributes({
  a_pos: {data: RIPPLE_POINTS, type: 'lnglat'},
  a_phase: {data: new Float32Array(ripplePhase), size: 1},
});
map.addLayer(rippleLayer);

// ================= 光柱 =================
// 每根光柱是从地面竖到 height 米的细柱,上面只画一段往上窜的亮条,窜出柱顶后从地面重来。
// 细柱用两片十字交叉的竖直面片,转动视角时总有一片朝向相机
var SPARK_COLORS = [
  [1, 0.6, 0.2],
  [1, 0, 1],
  [0, 0.8, 1],
];
var SPARK_COUNT = 90;
var SPARK_RANGE = 0.08; // 随机撒点的经纬度范围
var SPARK_TRAIL = 0.3; // 亮条长度占柱高的比例

var SPARK_VS = [
  'attribute vec3 a_pos;', // xy:柱脚局部坐标,z:柱高(米)
  'attribute vec2 a_side;', // 面片横向的单位方向,已乘左右侧符号
  'attribute vec2 a_info;', // x:0 柱脚 / 1 柱顶,y:起始相位
  'attribute vec3 a_color;',
  'uniform mat4 u_mvpMatrix;',
  'uniform float u_unitsPerPixel;',
  'uniform float u_halfWidth;',
  'varying vec2 v_info;',
  'varying vec3 v_color;',
  'void main() {',
  '    v_info = a_info;',
  '    v_color = a_color;',
  '    vec2 p = a_pos.xy + a_side * u_halfWidth * u_unitsPerPixel;',
  '    gl_Position = u_mvpMatrix * vec4(p, a_info.x * a_pos.z, 1.0);',
  '}',
].join('\n');

var SPARK_FS = [
  'precision highp float;',
  'uniform float u_opacity;',
  'uniform float u_time;',
  'uniform float u_duration;',
  'uniform float u_trail;',
  'varying vec2 v_info;',
  'varying vec3 v_color;',
  'void main() {',
  // 头部从柱脚升到柱顶再多走一个亮条长度,让尾巴也完整窜出去
  '    float head = mod(u_time / u_duration + v_info.y, 1.0 + u_trail);',
  '    float t = head - v_info.x;',
  '    if (t < 0.0 || t > u_trail) { discard; }',
  '    gl_FragColor = vec4(v_color, (1.0 - t / u_trail) * u_opacity);',
  '}',
].join('\n');

/**
 * @param {Object} layer 用它的 projectToLayer 换算局部坐标
 * @return {Object} attributes
 */
function buildSparks(layer) {
  // 两片面片各 6 个顶点:[柱脚/柱顶, 横向符号]
  var QUAD = [
    [0, -1],
    [0, 1],
    [1, -1],
    [0, 1],
    [1, 1],
    [1, -1],
  ];
  var DIRS = [
    [1, 0],
    [0, 1],
  ];
  var pos = [];
  var side = [];
  var info = [];
  var color = [];
  for (var i = 0; i < SPARK_COUNT; i++) {
    var xy = layer.projectToLayer([
      CENTER.lng + (Math.random() - 0.5) * SPARK_RANGE,
      CENTER.lat + (Math.random() - 0.5) * SPARK_RANGE,
    ]);
    var height = 400 + Math.random() * 1600;
    var phase = Math.random() * (1 + SPARK_TRAIL);
    var rgb = SPARK_COLORS[i % SPARK_COLORS.length];
    for (var d = 0; d < DIRS.length; d++) {
      for (var v = 0; v < QUAD.length; v++) {
        pos.push(xy[0], xy[1], height);
        side.push(DIRS[d][0] * QUAD[v][1], DIRS[d][1] * QUAD[v][1]);
        info.push(QUAD[v][0], phase);
        color.push(rgb[0], rgb[1], rgb[2]);
      }
    }
  }
  return {
    a_pos: {data: new Float32Array(pos), size: 3},
    a_side: {data: new Float32Array(side), size: 2},
    a_info: {data: new Float32Array(info), size: 2},
    a_color: {data: new Float32Array(color), size: 3},
  };
}

var sparkLayer = new BMap.WebGLCustomLayer({
  referCenter: CENTER,
  zIndex: 3,
  vertexShader: SPARK_VS,
  fragmentShader: SPARK_FS,
  uniforms: {u_halfWidth: 1, u_duration: 2.5, u_trail: SPARK_TRAIL},
  // 交叉处更亮
  renderState: {blend: 'additive'},
  animation: true,
  draw: {mode: 'TRIANGLES'},
});
sparkLayer.setAttributes(buildSparks(sparkLayer));
map.addLayer(sparkLayer);

用 WebGLCustomLayer 添加各种效果

预览