SOURCE

// 第三方FPS显示窗口
javascript: (function () {
    var script = document.createElement('script');
    script.onload = function () {
        var stats = new Stats();
        document.body.appendChild(stats.dom);
        requestAnimationFrame(function loop() {
        stats.update();
        requestAnimationFrame(loop);
        });
    };
    script.src = 'https://mrdoob.github.io/stats.js/build/stats.min.js';
    document.head.appendChild(script);
})();

var map = new AMap.Map('container', {
    center: [116.54, 39.79],
    zooms: [2, 20],
    zoom: 14,
    viewMode: '3D',
    pitch: 50,
});

var camera;
var renderer;
var scene;
var meshes = [];
let texture;
// 数据转换工具
var customCoords = map.customCoords;
// 数据使用转换工具进行转换，这个操作必须要提前执行（在获取镜头参数 函数之前执行），否则将会获得一个错误信息。
var data = customCoords.lngLatsToCoords([
    [116.52, 39.79],
    [116.54, 39.78],
    [116.56, 39.79],
]);

// 闭环数据
const testData = customCoords.lngLatsToCoords([
    [
        116.18657032,
        39.82981112
    ],
    [
        116.46982646,
        39.7899015
    ],
    [
        116.56519504,
        39.92211609
    ],
    [
        116.44064767,
        40.05080839
    ],
    [
        116.20151513,
        39.99412627
    ],
    [
        116.18657032,
        39.82981112
    ]
])

function calcDis([x1, y1], [x2, y2]) {
    return Math.sqrt(Math.pow(x2-x1, 2) + Math.pow(y2-y1, 2))
} 
// 创建 GL 图层
var gllayer = new AMap.GLCustomLayer({
    // 图层的层级
    zIndex: 8,
    // 初始化的操作，创建图层过程中执行一次。
    init: (gl) => {
        // 这里我们的地图模式是 3D，所以创建一个透视相机，相机的参数初始化可以随意设置，因为在 render 函数中，每一帧都需要同步相机参数，因此这里变得不那么重要。
        // 如果你需要 2D 地图（viewMode: '2D'），那么你需要创建一个正交相机
        camera = new THREE.PerspectiveCamera(
            60,
            window.innerWidth / window.innerHeight,
            100,
            1 << 30
        );

        renderer = new THREE.WebGLRenderer({
            context: gl, // 地图的 gl 上下文
            // alpha: true,
            // antialias: true,
            // canvas: gl.canvas,
        });

        // 自动清空画布这里必须设置为 false，否则地图底图将无法显示
        renderer.autoClear = false;
        scene = new THREE.Scene();

        // 环境光照和平行光
        var aLight = new THREE.AmbientLight(0xffffff, 1);
        // var dLight = new THREE.DirectionalLight(0xffffff, 1);
        // dLight.position.set(1000, -100, 900);
        // scene.add(dLight);
        scene.add(aLight);

        const base_64 = 'data:image/png;base64,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'
        // texture = new THREE.TextureLoader().load(
        //     'https://a.amap.com/jsapi_demos/static/demo-center-v2/three.jpeg'
        // );

        texture = new THREE.TextureLoader().load(base_64)
        // 纹理重复
        texture.wrapS = THREE.RepeatWrapping;
        texture.wrapT = THREE.RepeatWrapping;
        // texture.repeat.set(4, 1)

        // 
        texture.minFilter = THREE.LinearFilter;
        //  这里可以使用 three 的各种材质
        var mat = new THREE.MeshPhongMaterial({
            color: 0xfff0f0,
            depthTest: true,
            transparent: true,
            map: texture,
            // wireframe: true,
            side: THREE.DoubleSide, 
        });
        // var geo = new THREE.BoxBufferGeometry(1000, 1000, 1000);
        // for (let i = 0; i < data.length; i++) {
        //     const d = data[i];
        //     var mesh = new THREE.Mesh(geo, mat);
        //     mesh.position.set(d[0], d[1], 500);
        //     meshes.push({
        //         mesh,
        //         count: i,
        //     });
        //     scene.add(mesh);
        // }

        // 创建geometry
        const geometry = new THREE.BufferGeometry();
        let indices = [];
        let vetices = [];
        let normals = [];
        let colors = [];
        let uvs = [];

        const vec3List = []; 
        console.log(testData)
        for(let i =0; i< testData.length; i++) {
            const [x1, y1] = testData[i]
            vec3List.push([x1, y1, 100])
            vec3List.push([x1, y1, 2500])
        }

        // 竖(u)轴uv重复次数 
        // const repeatCount = 4;
        const t0 = [0, 0]
        const t1 = [1, 0]
        const t2 = [1, 1]
        const t3 = [0, 1] 

        for(let i =0; i< vec3List.length - 2; i++) {
            // 长宽比，用于uv拉伸
            const repeatCount  = Math.round(calcDis(vec3List[i], vec3List[i+2])/ 2500)
            if (i % 2 === 0) {
                // 下面片
                vetices = [...vetices, ...vec3List[i], ...vec3List[i+2], ...vec3List[i+1] ]
                uvs = [
                    ...uvs, 
                    t0[0] * repeatCount, t0[1],
                    t1[0] * repeatCount, t1[1],
                    t3[0] * repeatCount, t3[1],
                ]

                // 计算法线 (简单方法: 使用叉乘)
                const vA = new THREE.Vector3().fromArray(vec3List[i]);
                const vB = new THREE.Vector3().fromArray(vec3List[i+2]);
                const vC = new THREE.Vector3().fromArray(vec3List[i+1]);
                
                const ab = new THREE.Vector3().subVectors(vB, vA);
                const ac = new THREE.Vector3().subVectors(vC, vA);
                const normal = new THREE.Vector3().crossVectors(ab, ac).normalize();
                
                normals = [...normals, normal.x, normal.y, normal.z]; // 顶点A的法线
                normals = [...normals, normal.x, normal.y, normal.z]; // 顶点B的法线
                normals = [...normals, normal.x, normal.y, normal.z];
            } else {
                // 上面片
                vetices = [...vetices, ...vec3List[i], ...vec3List[i+1], ...vec3List[i+2] ]
                uvs = [
                    ...uvs, 
                    t3[0] * repeatCount, t3[1], 
                    t1[0] * repeatCount, t1[1],
                    t2[0] * repeatCount, t2[1],
                ]

                // 计算法线
                const vA = new THREE.Vector3().fromArray(vec3List[i]);
                const vB = new THREE.Vector3().fromArray(vec3List[i+1]);
                const vC = new THREE.Vector3().fromArray(vec3List[i+2]);
                
                const ab = new THREE.Vector3().subVectors(vB, vA);
                const ac = new THREE.Vector3().subVectors(vC, vA);
                const normal = new THREE.Vector3().crossVectors(ab, ac).normalize();
                
                normals = [...normals, normal.x, normal.y, normal.z]; // 顶点A的法线
                normals = [...normals, normal.x, normal.y, normal.z]; // 顶点B的法线
                normals = [...normals, normal.x, normal.y, normal.z]; // 顶点C的法线
            }
        }
        // geometry.setIndex( indices );
        geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( vetices, 3 ) );
        geometry.setAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) );
        // geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( colors, 3 ) );
        geometry.setAttribute( 'uv', new THREE.Float32BufferAttribute( uvs, 2 ) );

        testMesh = new THREE.Mesh( geometry, mat );
        scene.add( testMesh );

    },
    render: () => {
        // 这里必须执行！！重新设置 three 的 gl 上下文状态。
        renderer.resetState();
        // 重新设置图层的渲染中心点，将模型等物体的渲染中心点重置
        // 否则和 LOCA 可视化等多个图层能力使用的时候会出现物体位置偏移的问题
        customCoords.setCenter([116.52, 39.79]);
        var { near, far, fov, up, lookAt, position } =
        customCoords.getCameraParams();

        // 2D 地图下使用的正交相机
        // var { near, far, top, bottom, left, right, position, rotation } = customCoords.getCameraParams();

        // 这里的顺序不能颠倒，否则可能会出现绘制卡顿的效果。
        camera.near = near;
        camera.far = far;
        camera.fov = fov;
        camera.position.set(...position);
        camera.up.set(...up);
        camera.lookAt(...lookAt);
        camera.updateProjectionMatrix();

        // 2D 地图使用的正交相机参数赋值
        // camera.top = top;
        // camera.bottom = bottom;
        // camera.left = left;
        // camera.right = right;
        // camera.position.set(...position);
        // camera.updateProjectionMatrix();

        renderer.render(scene, camera);

        // 这里必须执行！！重新设置 three 的 gl 上下文状态。
        renderer.resetState();
    },
});
map.add(gllayer);

// 动画
let offset = 0
const speed = 0.01
function animate() {
    // for (let i = 0; i < meshes.length; i++) {
    //     let { mesh, count } = meshes[i];
    //     count += 1;
    //     mesh.rotateZ((count / 180) * Math.PI);
    // }
    
    offset += speed;
    if(offset >= 1) {
        offset = 0
    }
    console.log('texture: ', texture)
    texture.offset.set(0, offset)

    map.render();
    requestAnimationFrame(animate);
}

animate();

function onWindowResize() {
    camera.aspect = window.innerWidth / window.innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize(window.innerWidth, window.innerHeight);
}
window.addEventListener('resize', onWindowResize);

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta
      name="viewport"
      content="initial-scale=1.0, user-scalable=no, width=device-width"
    />
    <title>自定义三维图层</title>
    <link
      rel="stylesheet"
      href="https://a.amap.com/jsapi_demos/static/demo-center/css/demo-center.css"
    />
    <style>
      html,
      body,
      #container {
        width: 100%;
        height: 100%;
      }
    </style>
  </head>
  <body>
    <div id="container"></div>
    <script src="https://cdn.jsdelivr.net/npm/three@0.142/build/three.js"></script>
    <script src="//webapi.amap.com/maps?v=2.0&key=4ee1bad27d5a07c45f128e904022f5f2"></script>
  </body>
</html>