1. 从“光波”到“着色器”:理解动态扫光效果的本质
如果你看过一些智慧城市或者数据可视化的三维大屏项目,可能会对一个效果印象深刻:一道或几道光环,从城市中心或某个特定点向外扩散,光环扫过的区域,建筑和地面会随之亮起,形成一种极具科技感和动态感的视觉效果。AntV L7 等地理空间可视化库就经常使用这种效果来突出显示区域或引导视线。今天,我们不依赖任何现成的库,而是深入到图形学的底层,用 three.js 和 Shader 亲手实现它,并且要弄明白它为什么能工作。
这个效果看起来复杂,但核心原理其实非常直观。想象一下你向平静的湖面投下一颗石子,水波会一圈圈地向外扩散。我们的“扫光”效果就是这种视觉概念的数字化呈现。只不过,在三维世界里,我们判断一个点(在Shader中称为“片元”)是否被“光波”扫过,依据的不是水,而是距离。
具体来说,我们需要一个不断扩大的“光环”。这个光环不是一个实体,而是一个距离范围。我们设定一个中心点(比如城市中心坐标),然后计算场景中每一个像素点到这个中心点的距离。接着,我们定义两个关键变量:innerCircleWidth(内圈半径)和 circleWidth(光环的宽度)。如果某个像素点到中心的距离落在这个 [innerCircleWidth, innerCircleWidth + circleWidth] 的区间内,那么它就处于“光环”之中,我们就需要让它亮起来。
但直接让光环内的像素全亮会显得很生硬,就像用一个实心的圆环套上去一样,缺乏过渡和层次感。这就是我们需要 Shader,特别是片元着色器(Fragment Shader) 的原因。在片元着色器里,我们可以为每个像素进行“个性化定制”。我们不仅判断它在不在光环内,还要根据它距离内圈边界的远近,来计算一个混合系数,让颜色从原始状态平滑地过渡到高亮状态。这个平滑过渡的秘密武器,就是GLSL中的 mix() 函数。理解了“距离判断”和“混合插值”这两个核心,你就掌握了实现动态扫光效果的钥匙。
2. 庖丁解牛:Shader光照模型与距离计算
要真正玩转这个效果,我们不能只停留在“会用”的层面,还得稍微探究一下它背后的图形学思想。这能帮助你在未来创造出更多自定义的光影效果。
2.1 向点光源模型“借”思路
在原始文章中提到了一个很好的类比:WebGL中的点光源光照模型。点光源照射物体时,物体表面的亮度取决于该点到光源的距离以及该点的法线方向。距离越近,通常越亮。我们的扫光效果借鉴了其中的“距离衰减”思想,但做了极大的简化。
我们完全抛弃了复杂的法线计算、光线方向、镜面反射等物理光照模型。我们只关心一点:该片元(像素)到“光源中心”的距离。在这里,我们的“光源”不是一个发光的球,而是那个不断扩大的光环边界。这种简化使得计算量极小,效率极高,非常适合需要实时渲染大量几何体(如成千上万的建筑)的大屏场景。
2.2 核心算法:距离判断与混合系数
让我们把上面的思想翻译成具体的算法步骤,这将是编写Shader代码的蓝图:
- 获取世界坐标:在顶点着色器中,我们需要将顶点的局部坐标通过模型矩阵转换到世界空间坐标(
v_position),并传递给片元着色器。这是因为我们的光环中心(center)是在世界空间中定义的,必须统一坐标系才能进行距离计算。 - 计算距离:在片元着色器中,使用
length(v_position - center)计算当前片元到光环中心的距离dis。 - 区间判断:判断
dis是否大于innerCircleWidth且小于innerCircleWidth + circleWidth。如果是,则进入下一步的混合计算;否则,直接输出物体原本的颜色或纹理。 - 计算混合系数
r:这是实现渐变的关键。公式是r = (dis - innerCircleWidth) / circleWidth。这个公式非常巧妙:- 当
dis等于innerCircleWidth(刚好在内圈边界)时,r = 0。 - 当
dis等于innerCircleWidth + circleWidth(刚好在外圈边界)时,r = 1。 - 在光环宽度范围内,
r的值从 0 到 1 线性增长。 这个r值精确刻画了当前片元在光环宽度内的“相对位置”。
- 当
- 颜色混合:使用
mix()函数进行插值。mix(a, b, r)函数会根据r的值,返回一个介于a和b之间的颜色。当r=0时,返回a;当r=1时,返回b;当r=0.5时,返回a和b的中间值。 在我们的场景中:a是片元原本的颜色(例如从建筑纹理texture2D(building, vUv)中采样得到的颜色)。b是我们定义的高亮颜色(例如vec4(0.0, 0.0, 1.0, 0.9),一个半透明的蓝色)。r就是上一步计算出的混合系数。 这样,从内圈边界到外圈边界,颜色就会从原始纹理平滑地过渡到高亮蓝色,形成了视觉上的渐变光波。
3. 实战第一步:搭建Three.js场景与基础几何体
理论说得再多,不如动手敲代码来得实在。我们从一个干净的 three.js 项目开始,一步步构建出带有建筑和地面的基础场景。
3.1 初始化场景与渲染循环
首先,完成 three.js 的标准初始化流程。这里我习惯把相机、渲染器、光源的配置写清楚,方便后期调整。
// 初始化场景、相机、渲染器
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 10000);
camera.position.set(200, 300, 200); // 调整到一个合适的俯瞰角度
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(window.innerWidth, window.innerHeight);
renderer.setClearColor(0x000000); // 设置黑色背景
document.body.appendChild(renderer.domElement);
// 添加轨道控制器,方便用鼠标交互查看
const controls = new THREE.OrbitControls(camera, renderer.domElement);
controls.enableDamping = true; // 添加阻尼感,转动更平滑
// 添加基础光源
const ambientLight = new THREE.AmbientLight(0x404040); // 柔和的环境光
scene.add(ambientLight);
const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8); // 方向光产生明暗
directionalLight.position.set(100, 200, 150);
scene.add(directionalLight);
// 动画循环
function animate() {
requestAnimationFrame(animate);
controls.update(); // 更新控制器
// 这里后续会加入更新光环半径的逻辑
renderer.render(scene, camera);
}
animate();
3.2 创建模拟城市建筑与地面
为了演示效果,我们需要一些几何体。我们可以用简单的立方体阵列来模拟一片建筑群,并用一个巨大的平面作为地面。
// 创建地面
const groundGeometry = new THREE.PlaneGeometry(1000, 1000);
// 注意:我们先使用基础材质,后面会替换为自定义ShaderMaterial
const groundMaterial = new THREE.MeshBasicMaterial({ color: 0x333333 });
const ground = new THREE.Mesh(groundGeometry, groundMaterial);
ground.rotation.x = -Math.PI / 2; // 让平面平铺在地面上
scene.add(ground);
// 创建一片随机建筑
const buildingGroup = new THREE.Group();
const buildingCount = 50;
for (let i = 0; i < buildingCount; i++) {
const width = Math.random() * 15 + 5;
const depth = Math.random() * 15 + 5;
const height = Math.random() * 50 + 20; // 随机高度
const geometry = new THREE.BoxGeometry(width, height, depth);
geometry.translate(0, height / 2, 0); // 将几何体原点移到底部中心,方便放置
// 同样,先使用基础材质
const material = new THREE.MeshPhongMaterial({ color: 0xaaaaaa });
const building = new THREE.Mesh(geometry, material);
building.position.x = (Math.random() - 0.5) * 800; // 在XZ平面随机分布
building.position.z = (Math.random() - 0.5) * 800;
buildingGroup.add(building);
}
scene.add(buildingGroup);
现在,你应该能看到一个灰色的地面和一片灰色的随机建筑。这是我们施展Shader魔法前的“白模”。
4. 注入灵魂:编写自定义ShaderMaterial
接下来是最核心的部分——创建我们自己的着色器材质。我们需要为地面和建筑分别编写,但它们的片元着色器逻辑是高度相似的。
4.1 地面着色器:实现环形渐变光波
我们先从地面的Shader开始,因为它不涉及纹理,逻辑更清晰。创建一个 THREE.ShaderMaterial,并定义好需要的 uniforms(统一变量,可以从JavaScript中动态传入)。
// 地面的顶点着色器 - 主要任务是传递坐标和UV
const groundVertexShader = `
varying vec2 vUv;
varying vec3 vPositionWorld; // 传递世界坐标
void main() {
vUv = uv;
vec4 worldPosition = modelMatrix * vec4(position, 1.0);
vPositionWorld = worldPosition.xyz;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;
// 地面的片元着色器 - 核心逻辑在这里
const groundFragmentShader = `
varying vec2 vUv;
varying vec3 vPositionWorld;
// 从JS传入的Uniforms
uniform float uInnerRadius; // 内圈半径
uniform float uRingWidth; // 光环宽度
uniform vec3 uCenter; // 光环中心(世界坐标)
uniform vec3 uBaseColor; // 地面基础颜色
uniform vec3 uGlowColor; // 高亮光颜色
uniform float uGlowOpacity; // 高亮光的透明度
void main() {
// 计算当前片元到光环中心的距离
float distanceToCenter = distance(vPositionWorld, uCenter);
// 判断是否在光环范围内
if (distanceToCenter > uInnerRadius && distanceToCenter < (uInnerRadius + uRingWidth)) {
// 计算混合系数:0在内圈边界,1在外圈边界
float mixRatio = (distanceToCenter - uInnerRadius) / uRingWidth;
// 使用mix函数混合基础色和高亮色
vec3 mixedColor = mix(uBaseColor, uGlowColor, mixRatio);
gl_FragColor = vec4(mixedColor, 1.0); // 地面通常不透明
} else {
// 不在光环内,显示基础颜色
gl_FragColor = vec4(uBaseColor, 1.0);
}
}
`;
// 创建地面的Shader材质
const groundShaderMaterial = new THREE.ShaderMaterial({
uniforms: {
uInnerRadius: { value: 0.0 },
uRingWidth: { value: 100.0 },
uCenter: { value: new THREE.Vector3(0, 0, 0) },
uBaseColor: { value: new THREE.Color(0.2, 0.2, 0.2) }, // 深灰色地面
uGlowColor: { value: new THREE.Color(0.0, 0.5, 1.0) }, // 蓝色光效
uGlowOpacity: { value: 1.0 }
},
vertexShader: groundVertexShader,
fragmentShader: groundFragmentShader
});
// 用这个Shader材质替换之前地面的基础材质
ground.material = groundShaderMaterial;
刷新页面,你可能还看不到效果,因为 uInnerRadius 还是0。但代码结构已经搭好了。
4.2 建筑着色器:融合纹理与动态光效
建筑的Shader需要多处理一步:纹理采样。我们既要显示建筑本身的纹理,又要让扫光效果叠加在上面。
// 加载一张建筑纹理贴图(这里可以用简单的砖墙或窗户贴图)
const textureLoader = new THREE.TextureLoader();
const buildingTexture = textureLoader.load('path/to/building_texture.jpg');
buildingTexture.wrapS = THREE.RepeatWrapping;
buildingTexture.wrapT = THREE.RepeatWrapping;
// 建筑的顶点着色器
const buildingVertexShader = `
varying vec2 vUv;
varying vec3 vPositionWorld;
void main() {
vUv = uv;
vec4 worldPosition = modelMatrix * vec4(position, 1.0);
vPositionWorld = worldPosition.xyz;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;
// 建筑的片元着色器
const buildingFragmentShader = `
varying vec2 vUv;
varying vec3 vPositionWorld;
uniform float uInnerRadius;
uniform float uRingWidth;
uniform vec3 uCenter;
uniform vec3 uGlowColor;
uniform float uGlowOpacity;
uniform sampler2D uBuildingTexture; // 纹理采样器
void main() {
// 首先采样得到建筑本身的颜色
vec4 textureColor = texture2D(uBuildingTexture, vUv);
float distanceToCenter = distance(vPositionWorld, uCenter);
if (distanceToCenter > uInnerRadius && distanceToCenter < (uInnerRadius + uRingWidth)) {
float mixRatio = (distanceToCenter - uInnerRadius) / uRingWidth;
// 关键:将纹理颜色与高亮光颜色进行混合
vec4 glowColor = vec4(uGlowColor, uGlowOpacity);
gl_FragColor = mix(textureColor, glowColor, mixRatio);
} else {
// 不在光环内,直接显示纹理
gl_FragColor = textureColor;
}
}
`;
// 创建建筑的Shader材质
const buildingShaderMaterial = new THREE.ShaderMaterial({
uniforms: {
uInnerRadius: { value: 0.0 },
uRingWidth: { value: 100.0 },
uCenter: { value: new THREE.Vector3(0, 0, 0) },
uGlowColor: { value: new THREE.Color(0.0, 0.5, 1.0) },
uGlowOpacity: { value: 0.7 }, // 给一些透明度,让纹理能透出来
uBuildingTexture: { value: buildingTexture }
},
vertexShader: buildingVertexShader,
fragmentShader: buildingFragmentShader
});
// 将建筑群中每个建筑的材质替换为我们的Shader材质
buildingGroup.children.forEach(building => {
building.material = buildingShaderMaterial;
});
现在,所有材质都准备就绪了。我们离动态效果只差最后一步。
5. 让光波动起来:在动画循环中更新Uniform
静态的光环没意思,我们要的是扩散的动画。这非常简单,只需要在 animate 函数中,每帧增加 uInnerRadius 的值即可。
// 在animate函数中
function animate() {
requestAnimationFrame(animate);
controls.update();
// 核心动画逻辑:让内圈半径不断增大
let speed = 2.0; // 扩散速度,可以调整
groundShaderMaterial.uniforms.uInnerRadius.value += speed;
buildingShaderMaterial.uniforms.uInnerRadius.value += speed; // 确保地面和建筑同步
// 重置逻辑:当光环完全移出场景时,重置半径,形成循环
const maxRadius = 600; // 根据你的场景大小设定
if (groundShaderMaterial.uniforms.uInnerRadius.value > maxRadius) {
groundShaderMaterial.uniforms.uInnerRadius.value = -buildingShaderMaterial.uniforms.uRingWidth.value;
buildingShaderMaterial.uniforms.uInnerRadius.value = -buildingShaderMaterial.uniforms.uRingWidth.value;
}
renderer.render(scene, camera);
}
注意这里的重置逻辑:我们把 uInnerRadius 重置为 -uRingWidth,而不是 0。这是为了让光环在从中心开始扩散前,是完全不可见的(因为内圈半径为负,外圈半径 uInnerRadius + uRingWidth 可能还是个很小的正数,甚至为负)。当 uInnerRadius 从负值逐渐增加到0时,光环才从中心点开始出现并扩散,这样动画循环会更加平滑,没有突兀的跳变。
现在,运行你的代码!你应该能看到一道蓝色的光波从场景中心不断向外扩散,扫过建筑和地面,并带有平滑的渐变效果。恭喜你,你已经成功用Shader模拟了L7的动态扫光效果!
6. 效果调优与进阶技巧
实现基础效果只是第一步。要让这个效果真正融入你的项目并出彩,还需要一些调优和进阶技巧。
6.1 参数调优:找到视觉甜点
代码中的几个 uniform 参数对最终视觉效果影响巨大,我根据经验给你一些调试方向:
uRingWidth(光环宽度):控制光波的“粗细”。值太小,光波像细线;值太大,光波像一片弥漫的光雾。对于城市尺度,设置在80-150之间比较合适。你可以尝试让它随时间变化,制造出“脉冲”效果。uGlowColor和uGlowOpacity(高亮颜色与透明度):这决定了光波的色彩和强度。蓝色(0.0, 0.5, 1.0)是经典的科技色。尝试金色(1.0, 0.8, 0.0)或紫色(0.6, 0.2, 1.0)会有不同感觉。透明度建议设置在0.5-0.8之间,让建筑纹理若隐若现,效果更佳。- 扩散速度:动画循环中的
speed变量。太快会显得急促,太慢则拖沓。根据场景大小和想要营造的氛围来定。一个技巧是让速度与半径相关,例如越往外扩散速度越慢,模拟能量衰减。 - 混合函数:我们一直用的是
mix()线性插值。但GLSL提供了更强大的smoothstep(edge0, edge1, x)函数。你可以用smoothstep(uInnerRadius, uInnerRadius+uRingWidth, distanceToCenter)来替代mixRatio的计算,它能产生在边界处更加平滑的过渡,避免出现生硬的线条感。
6.2 性能考量与优化建议
当你的场景中有数万个建筑时,Shader计算量会激增。这里有几个优化思路:
- 共享Uniform:确保地面和所有建筑材质实例使用的是同一个
uniform对象引用,而不是每个材质拷贝一份。这样你在动画循环中只需要更新一个对象,所有材质都会同步生效,性能最佳。const sharedUniforms = { uInnerRadius: { value: 0.0 }, uRingWidth: { value: 100.0 }, uCenter: { value: new THREE.Vector3(0,0,0) }, uGlowColor: { value: new THREE.Color(0.0, 0.5, 1.0) } }; const groundMat = new THREE.ShaderMaterial({ uniforms: sharedUniforms, ... }); const buildingMat = new THREE.ShaderMaterial({ uniforms: sharedUniforms, ... }); // 注意:这里直接引用同一个对象 - 距离计算优化:
distance()函数内部是开方运算。对于性能极端敏感的场景,可以比较距离的平方,避免开方。float disSq = dot(vPositionWorld - uCenter, vPositionWorld - uCenter); float innerSq = uInnerRadius * uInnerRadius; float outerSq = (uInnerRadius + uRingWidth) * (uRingWidth + uInnerRadius); // 注意括号 if (disSq > innerSq && disSq < outerSq) { // ... 使用开方后的距离进行插值,或者重新设计插值公式 } - 使用后处理(Post-processing):另一种完全不同的思路是,将整个场景渲染到一张纹理上,然后在一个全屏的后期处理Shader中统一施加这个光环效果。这样计算量与场景复杂度无关,只和屏幕分辨率有关。对于超大规模场景,这可能是更好的选择。你可以研究一下 three.js 的
EffectComposer和ShaderPass。
6.3 创意扩展:不止于圆形光波
掌握了核心原理后,你可以发挥创意,改变“距离场”的定义,创造出更多样的效果:
- 方向性光波:将距离计算改为点到一条线的距离,可以实现从一条线向外扩散的“浪潮”效果。
- 多个光源:在Shader中定义多个
uCenter,计算到每个中心的距离,然后取最小值或进行颜色叠加,可以实现多个源头同时扩散的复杂光效。 - 非均匀扩散:不让
uInnerRadius匀速增加,而是用Math.sin()或噪声函数来控制其变化,制造出呼吸般起伏的节奏感。 - 添加衰减:在混合时,不仅根据径向位置,还根据到中心的绝对距离增加一个衰减系数,让远处的光波更弱。
我在一个数据可视化项目中就尝试过多个交互式光源。用户点击地图上的某个区域,就会以该点为中心触发一次扫光,同时高亮该区域的相关数据。这种将视觉效果与用户交互深度结合的方式,极大地提升了应用的体验感和科技感。Shader编程的魅力就在于此,它给你了一块画布和一套极其灵活的画笔,限制你的只有想象力。从模仿一个经典效果开始,理解其原理,然后大胆地去修改、组合、创造,这才是学习图形学最有趣的路径。
684



被折叠的 条评论
为什么被折叠?



