The Book of Shaders 第 9 章精读:GLSL 空间平铺(Tiling)与程序化重复图案实战
The Book of Shaders 第 9 章精读:GLSL 空间平铺(Tiling)与程序化重复图案实战
本文精读 The Book of Shaders 第 9 章(对应仓库 09/README-it.md),围绕"重复图案(Patterns)"这一核心主题展开:先讲清以
fract()折叠坐标空间实现平铺的原理,再依次演示单元内矩阵变换、奇偶行偏移砌砖、Truchet 瓦片旋转复用,最终引导读者自行设计图案规则。读完你将掌握一套可复用的平铺工具函数(tile()、rotate2D()、brickTile()、rotateTilePattern()),能够用纯片元着色器绘制网格、砖墙、棋盘与无限可组合的装饰图案,并理解为什么"重复形状"在片元着色器中不会增加任何计算开销。
为什么片元着色器天生适合做重复图案
片元着色器的执行方式是**逐像素(pixel-by-pixel)**的:无论你在一张画布上重复多少次某个形状,GPU 为每个像素执行的指令数量都保持不变。这个特性意味着,绘制 1 个圆和绘制 100 个圆,计算量完全一样——差别只在于你把坐标"折叠"到哪个空间里。因此,平铺图案(tile pattern)几乎是为片元着色器量身定做的主题。
本章的总体策略与前一章一脉相承:把归一化坐标(0.0~1.0)放大若干倍,于是你在 0.0~1.0 之间绘制的形状,就会沿着画布被重复成一张网格。正如书中所引 10 PRINT(MIT Press, 2013)的那句话:"网格为人类直觉与创造提供了可以运作、也可以颠覆的框架;在自然的混沌之中,图案提供了对比与秩序的承诺。"从陶器上的早期纹样到罗马浴场的几何马赛克,人类一直在用网格装饰生活——本章就是把这种古老的装饰冲动,翻译成 GLSL 代码。
核心基石:fract() 与"折叠空间"
fract() 到底是什么
先复习 fract():它返回一个数字的小数部分,本质上就是 mod(x, 1.0)(参见 mod() 词条)。GLSL 规范中的定义是:
fract(x) = x - floor(x)
即丢掉整数部分,只保留小数点后的数值。仓库 glossary/fract/README.md 中给出了完整的重载声明:float fract(float x)、vec2 fract(vec2 x)、vec3 fract(vec3 x)、vec4 fract(vec4 x),所以它可以直接作用于我们惯用的 vec2 st 坐标。
既然我们的归一化坐标变量 st 本身就在 0.0~1.0 之间,直接对它做 fract() 是毫无意义的:
void main(){
vec2 st = gl_FragCoord.xy/u_resolution;
vec3 color = vec3(0.0);
st = fract(st);
color = vec3(st,0.0);
gl_FragColor = vec4(color,1.0);
}
(注意:本书代码为 GLSL 1.x 风格,使用 gl_FragCoord 与 gl_FragColor,对应的 WebGL 环境需在片段着色器入口前声明 uniform vec2 u_resolution; 等变量。)
放大坐标再折叠:一次得到三份插值
但如果我们先把归一化坐标系放大 3 倍再折叠,就完全不同了:st 会依次得到三段 0-1 之间的线性插值——第一段对应 0-1,第二段对应 1-2 的小数部分,第三段对应 2-3 的小数部分。仓库 09/grid-making.frag 完整演示了这一过程:
// Author @patriciogv - 2015
#ifdef GL_ES
precision mediump float;
#endif
uniform vec2 u_resolution;
uniform float u_time;
float circle(in vec2 _st, in float _radius){
vec2 l = _st-vec2(0.5);
return 1.-smoothstep(_radius-(_radius*0.01),
_radius+(_radius*0.01),
dot(l,l)*4.0);
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution;
vec3 color = vec3(0.0);
st *= 3.0; // Scale up the space by 3
st = fract(st); // Wrap around 1.0
// Now we have 9 spaces that go from 0-1
color = vec3(st,0.0);
//color = vec3(circle(st,0.5));
gl_FragColor = vec4(color,1.0);
}
st *= 3.0 把坐标放大,st = fract(st) 把超出 1.0 的部分折叠回 0,1),于是画布被切成 3×3 共 9 个子空间;又因为 x、y 被等比例放大,子空间的长宽比保持不变,我们之前画过的任何形状(如 circle())放进每个子空间都会保持原样。取消第 27 行注释(color = vec3(circle(st,0.5));),就能在每一个子空间里各画一个圆。运行结果即仓库中的 [09/grid-making.png,可以看到 9 个完全一致的渐变方块(未启用 circle() 时显示的是坐标本身的渐变)。
关于"放大→折叠"的数值细节,仓库 09/notes.md 中收录了一位读者的手记,给出了非常直观的对照表(以放大 3 倍为例):
first block
st = 0.00 | st * 3 = 0.00 | fract( st * 3 ) = 0.00
st = 0.10 | st * 3 = 0.30 | fract( st * 3 ) = 0.30
st = 0.20 | st * 3 = 0.60 | fract( st * 3 ) = 0.60
st = 0.30 | st * 3 = 0.90 | fract( st * 3 ) = 0.90
second block
st = 0.40 | st * 3 = 1.20 | fract( st * 3 ) = 0.20
st = 0.50 | st * 3 = 1.50 | fract( st * 3 ) = 0.50
st = 0.60 | st * 3 = 1.80 | fract( st * 3 ) = 0.80
third block
st = 0.70 | st * 3 = 2.10 | fract( st * 3 ) = 0.10
st = 0.80 | st * 3 = 2.40 | fract( st * 3 ) = 0.40
st = 0.90 | st * 3 = 2.70 | fract( st * 3 ) = 0.70
st = 1.00 | st * 3 = 3.00 | fract( st * 3 ) = 1.00
可以看到,第一个区间内 st * 3 与 fract(st * 3) 完全相等;一旦 st * 3 超过 1.0,fract() 立刻把数值"兜"回 [0,1) 区间——这正是平铺魔法发生的地方。
三个基础练习
原文档给出了三个加深理解的练习,建议逐一在 09/grid-making.frag 上动手:
- 换倍数:把空间乘以不同的数字(试试小数,也试试 x、y 用不同倍数)。不同倍数决定网格密度;x、y 不等倍则会让格子变成长方形。
- 封装成函数:把"放大 + 折叠"封装成可复用函数。仓库中几乎所有后续示例都用了同一个工具函数,例如 09/checks.frag、09/truchet.frag 里的:
vec2 tile(vec2 _st, float _zoom){
_st *= _zoom;
return fract(_st);
}
- 做井字棋:把空间分成 3 行 3 列,想办法判断当前片元(thread)位于哪一列、哪一行,并据此切换显示不同的形状,最终拼出一个可玩的井字棋。判断行列需要用到下面的"奇偶检测"技巧。
在图案单元内应用矩阵变换
每个子单元(cell)都是归一化坐标系的一个缩小版,因此我们可以对单元内部施加矩阵变换:平移、旋转或缩放单元内的空间。仓库 09/checks.frag 就是典型范例——先平铺成 4×4 的网格,再在每个单元内把空间旋转 45°,然后绘制一个平滑边缘的方块,得到棋盘格效果:
// Author @patriciogv ( patriciogonzalezvivo.com ) - 2015
#ifdef GL_ES
precision mediump float;
#endif
uniform vec2 u_resolution;
uniform float u_time;
#define PI 3.14159265358979323846
vec2 rotate2D(vec2 _st, float _angle){
_st -= 0.5;
_st = mat2(cos(_angle),-sin(_angle),
sin(_angle),cos(_angle)) * _st;
_st += 0.5;
return _st;
}
vec2 tile(vec2 _st, float _zoom){
_st *= _zoom;
return fract(_st);
}
float box(vec2 _st, vec2 _size, float _smoothEdges){
_size = vec2(0.5)-_size*0.5;
vec2 aa = vec2(_smoothEdges*0.5);
vec2 uv = smoothstep(_size,_size+aa,_st);
uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st);
return uv.x*uv.y;
}
void main(void){
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec3 color = vec3(0.0);
// Divide the space in 4
st = tile(st,4.);
// Use a matrix to rotate the space 45 degrees
st = rotate2D(st,PI*0.25);
// Draw a square
color = vec3(box(st,vec2(0.7),0.01));
// color = vec3(st,0.0);
gl_FragColor = vec4(color,1.0);
}
关键点在于 rotate2D() 的写法:先把坐标平移到中心 -0.5,乘以旋转矩阵 mat2(cos, -sin, sin, cos),再平移回 +0.5——这样旋转是围绕单元中心而非原点进行的。这一套"平移-旋转-平移"模式也是后续所有旋转类图案的公共底座。
围绕这套技法,原文档建议的练习包括:
- 思考有趣的动画方式:分别用颜色、形状、运动三个维度做三种不同的动画(可引入
u_time驱动旋转角或平铺缩放); - 通过组合不同形状复现更复杂的图案。仓库 09/diamondtiles.frag(Diamond Tiles)展示了如何在平铺基础上叠加"半单元偏移"(
offset()函数把每个单元按象限再平移 ±0.5)与 45° 旋转,最终用两个不同尺寸的方块做加减混合:vec3 color = vec3( box(offsetSt,vec2(0.95),0.01) - box(st,vec2(0.3),0.01) + 2.*box(st,vec2(0.2),0.01) ); - 叠加多层图案:把不同缩放倍率的平铺结果混合在一起,甚至可以组合出苏格兰 Tartan 格纹风格的自定义图案。
偏移图案:用奇偶检测砌一堵砖墙
问题:砖墙为什么错位
想象一堵砖墙:每隔一行的砖,在 x 方向上整体错开半块砖。如何在着色器里实现这种交错平铺?仓库 09/brick.jpg 就是现实砖墙的参考图。
第一步是判断当前片元所在的行是奇数行还是偶数行——奇数行需要加半块偏移,偶数行保持原样。
三种"奇偶检测"写法:三元、step、floor
用 mod() 对 2.0 取模,再判断结果是否小于 1.0,即可区分奇偶。原文档给出了两条可互相替换的公式:
y = mod(x,2.0);
// y = mod(x,2.0) < 1.0 ? 0. : 1. ;
// y = step(1.0,mod(x,2.0));
- 第二行是三元运算符(ternary operator):
mod(x,2.0)小于1.0返回0.0(偶数行),否则返回1.0(奇数行); - 第三行用 step() 完成同一件事:
step(edge, x)在x >= edge时返回1.0,否则返回0.0。
书中特别强调:能使用内置函数就用内置函数。虽然我们很难知道每块显卡内部如何优化与编译代码,但可以稳妥地假设内置函数比手写逻辑更快。仓库 09/notes.md 还从底层补充了一层解释:三元运算符本质上是伪装的 if,程序被迫分支并分别求值两条路径,这会拖慢执行;而 step() 是纯数值比较,不需要分支。该笔记还给出了一种替代写法:
y = floor( mod( x, 2.0 ) );
mod(x,2.0) 的结果在 [0,2) 之间,floor() 后偶数行为 0.0、奇数行为 1.0,效果与 step(1.0, mod(x,2.0)) 一致;甚至可以先转 int 再转回 float 来丢弃小数部分:
y = float( int( mod( x, 2.0 ) ) );
(把 float 转 int 会丢弃小数点后的部分,等价于 floor(),但记得要把结果重新转回 float。)这些都是同一逻辑的不同实现,实战中可依据目标平台特性取舍。
brickTile():把偏移写进平铺函数
仓库 09/bricks.frag 把"奇偶检测 + 半砖偏移"直接做进了平铺函数:
vec2 brickTile(vec2 _st, float _zoom){
_st *= _zoom;
// Here is where the offset is happening
_st.x += step(1., mod(_st.y,2.0)) * 0.5;
return fract(_st);
}
第 14 行就是核心:step(1., mod(_st.y,2.0)) 按行号奇偶输出 0.0/1.0,再乘以偏移量 0.5。偶数行结果为 0.0 × 0.5 = 0.0,x 不动;奇数行结果为 1.0 × 0.5 = 0.5,整个坐标系在 x 方向平移半格——于是砖缝自然错开,形成砖墙效果。
主函数中还藏着两个值得动手的实验:
// Modern metric brick of 215mm x 102.5mm x 65mm
// http://www.jaharrison.me.uk/Brickwork/Sizes.html
// st /= vec2(2.15,0.65)/1.5; // 第 32 行,取消注释可得到"现代砖"的长宽比
// Apply the brick tiling
st = brickTile(st,5.0);
color = vec3(box(st,vec2(0.9)));
// Uncomment to see the space coordinates
// color = vec3(st,0.0); // 第 40 行,取消注释可用红/绿通道可视化坐标空间
- 取消第 32 行注释:按真实"现代砖"比例 215mm × 102.5mm × 65mm 拉伸坐标空间,砖块会从正方形变成扁平的长方砖;
- 取消第 40 行注释:用红、绿通道直接显示平铺后的坐标,可以直观看到每一行如何被折叠与偏移。
砖墙练习
- 时间驱动偏移:让偏移量随
u_time变化,动画化这堵砖墙; - 双向漂移:偶数行向左移、奇数行向右移;
- 换方向:把同样的奇偶偏移应用到列上;
- xy 组合:同时在 x、y 两个轴做偏移,得到类似"游动点阵"的效果。仓库 09/marching_dots.frag 给出了参考实现——它的
movingTiles()函数按时间相位在横/纵两个方向上交替移动相邻行/列:
vec2 movingTiles(vec2 _st, float _zoom, float _speed){
_st *= _zoom;
float time = u_time*_speed;
if( fract(time)>0.5 ){
if (fract( _st.y * 0.5) > 0.5){
_st.x += fract(time)*2.0;
} else {
_st.x -= fract(time)*2.0;
}
} else {
if (fract( _st.x * 0.5) > 0.5){
_st.y += fract(time)*2.0;
} else {
_st.y -= fract(time)*2.0;
}
}
return fract(_st);
}
Truchet 瓦片:让同一个元素按位置旋转复用
学会了判断"单元在奇数行还是偶数列"之后,就能做到一件很酷的事:根据单元位置,复用同一个设计元素。Truchet 瓦片(Truchet Tiles)正是经典案例——单个设计元素(比如一条对角线)可以有 4 种朝向,拼起来就能构成无限多种复杂图案:
仓库 09/truchet.frag 的核心是 rotateTilePattern() 函数——把空间细分 2×2 为四个单元,给每个单元编一个序号,再按序号施加不同的旋转:
vec2 rotateTilePattern(vec2 _st){
// Scale the coordinate system by 2x2
_st *= 2.0;
// Give each cell an index number
// according to its position
float index = 0.0;
index += step(1., mod(_st.x,2.0));
index += step(1., mod(_st.y,2.0))*2.0;
// |
// 2 | 3
// |
//--------------
// |
// 0 | 1
// |
// Make each cell between 0.0 - 1.0
_st = fract(_st);
// Rotate each cell according to the index
if(index == 1.0){
// Rotate cell 1 by 90 degrees
_st = rotate2D(_st,PI*0.5);
} else if(index == 2.0){
// Rotate cell 2 by -90 degrees
_st = rotate2D(_st,PI*-0.5);
} else if(index == 3.0){
// Rotate cell 3 by 180 degrees
_st = rotate2D(_st,PI);
}
return _st;
}
这段代码可以拆解成三个步骤:
- 编码:
_st *= 2.0把空间放大成 2×2;用step(1., mod(_st.x,2.0))和step(1., mod(_st.y,2.0))*2.0把行列奇偶信息编码成index(0~3),对应注释中画出的四象限布局:0=左下、1=右下、2=左上、3=右上; - 折叠:
_st = fract(_st)让每个单元回到 [0,1); - 旋转:根据
index对单元内的空间施加 0°/90°/-90°/180° 旋转。
主函数里先 tile(st,3.0) 得到 3×3 网格,再逐单元套用旋转规则,最后用 step(st.x, st.y) 画黑白三角:
void main (void) {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
st = tile(st,3.0);
st = rotateTilePattern(st);
// Make more interesting combinations
// st = tile(st,2.0);
// st = rotate2D(st,-PI*u_time*0.25);
// st = rotateTilePattern(st*2.);
// st = rotate2D(st,PI*u_time*0.25);
// step(st.x,st.y) just makes a b&w triangles
// but you can use whatever design you want.
gl_FragColor = vec4(vec3(step(st.x,st.y)),1.0);
}
原文档的练习路线非常清晰:
- 注释、取消注释、复制第 69~72 行(即上面主函数中被注释的 4 行组合代码),用"再次平铺 + 再次旋转 + 随时间旋转"的组合产生新图案;
- 替换元素:把黑白三角形换成半圆、旋转的正方形或线段等其他元素;
- 按位置旋转:编写更多"元素朝向取决于位置"的图案;
- 换属性:让图案根据位置改变其他属性(颜色、大小、透明度等);
- 跳出图案思维:把"按位置复用元素"的原则应用到非图案场景。仓库 09/iching-01.frag 就是书中的范例——用同样的思想把空间切成 10×10 的单元,每个单元根据行列序号
ipos.x + ipos.y + t从 64 种六爻组合(hex(fpos, ipos.x+ipos.y+t),内部通过mod(remain,2.)逐位解码)中选出一卦,构成不断滚动的《易经》六十四卦方阵。这个例子完美展示了"位置即信息"的威力:单元编号本身可以被当成一个查询键。
打造你自己的图案规则
制作程序化图案,本质上是一场"寻找最小可复用元素"的思维训练。这是一项古老的手艺:从古希腊的回纹(meander)到中国的格纹(lattice)装饰,人类一直在用图案装点织物、地面与器物边缘;而艺术与设计史之所以迷人,正在于创作者在秩序的确定性与变化、混沌带来的惊喜之间反复走钢丝——从阿拉伯几何纹样到绚丽的非洲织物,图案的宇宙远比想象中广阔。原文档随附的 09/geometricpatters.png 取自 Franz Sales Meyer 1920 年的《装饰手册》,正是这种历史装饰语汇的缩影。
在本仓库中,围绕本章主题还有更多可参考的进阶实现:
- 09/grid.frag:把
tile()与box()组合的最简网格平铺模板; - 09/rotatedtiles.frag:Truchet 思想的变体——
rotateTile()用fract(_st.x * 0.5)判断象限,并在每个单元里绘制随时间旋转的平滑三角形; - 09/mirrortiles.frag 与 09/deco.frag、09/zigzag.frag:利用
fract(_st.y * 0.5) > 0.5判断奇偶行后对坐标做镜像(_st.y = 1.0 - _st.y)或半格平移,生成连续波动的镜面纹样; - 09/grid-side.frag:在 10×10 平铺单元中用
smoothstep绘制 X 形交叉线; - 开篇展示的 09/dots5.frag:把两套不同缩放(7× 与 3×)的平铺网格叠加,用
mix()混合出 Nina Warmerdam《The IMPRINT Project》风格的动态圆点图案。
至此,本章结束了"算法绘制(Algorithmic Drawing)"这一整章的主题。"平铺"教会我们的核心能力,是把一个复杂的整体问题分解成"一个最小单元 + 一条位置规则":fract() 负责折叠空间,mod()/step() 负责读取位置的奇偶信息,rotate2D() 与矩阵负责在单元内做变换——三者组合,即可在不增加任何计算量的前提下,生成密度任意、复杂度无限的图案。下一章开始,我们将给着色器引入"熵"(entropy),在这样规整的网格之上叠加随机性,迈向生成式设计(generative design)的世界。



