The Book of Shaders 第 9 章精读:GLSL 空间平铺(Tiling)与程序化重复图案实战

原创2026-10-14 18:48:381,608 阅读

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() 时显示的是坐标本身的渐变)。

grid-making.frag 的运行结果:坐标放大 3 倍并 fract 折叠后形成 3×3 的 9 个重复子空间

关于"放大→折叠"的数值细节,仓库 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 上动手:

  1. 换倍数:把空间乘以不同的数字(试试小数,也试试 x、y 用不同倍数)。不同倍数决定网格密度;x、y 不等倍则会让格子变成长方形。
  2. 封装成函数:把"放大 + 折叠"封装成可复用函数。仓库中几乎所有后续示例都用了同一个工具函数,例如 09/checks.frag、09/truchet.frag 里的:
vec2 tile(vec2 _st, float _zoom){
    _st *= _zoom;
    return fract(_st);
}
  1. 做井字棋:把空间分成 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 就是现实砖墙的参考图。

真实砖墙照片:相邻行在 x 方向错开半块砖,这是本节要模拟的目标

第一步是判断当前片元所在的行是奇数行还是偶数行——奇数行需要加半块偏移,偶数行保持原样。

三种"奇偶检测"写法:三元、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 种朝向,拼起来就能构成无限多种复杂图案:

Truchet 瓦片的 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;
}

这段代码可以拆解成三个步骤:

  1. 编码:_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=右上;
  2. 折叠:_st = fract(_st) 让每个单元回到 [0,1);
  3. 旋转:根据 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)的世界。

登录后查看全文
thebookofshaders