Fragment Shader 入门:从并行像素计算到 GLSL 语法——《The Book of Shaders》第一章详解

原创2026-10-14 22:54:081,342 阅读

Fragment Shader 入门:从并行像素计算到 GLSL 语法——《The Book of Shaders》第一章详解

本文以开源图书《The Book of Shaders》(本仓库即该书的完整源码与文档)第一章 Getting started(What is a fragment shader?) 为核心骨架展开。本章回答了三个关键问题:Fragment Shader 到底是什么、为什么它如此之快、以及为什么它对初学者"出了名的难"。读完本文,你将理解 shader 与 CPU 串行编程的本质差异(并行、无记忆、盲线程),掌握 GLSL 的第一批核心概念(main()、gl_FragColor、vec4、精度与预处理器),并能通过仓库中的交互式示例与真实 .frag 源码亲手验证每一个结论。


一、什么是 Fragment Shader:一场"图形界的印刷革命"

在本书的引言章节中,作者将 fragment shader 比作"图形界的古腾堡印刷机"(Gutenberg's press for graphics),第一章的开篇则延续了这一比喻,用印刷术的历史演进解释了两种截然不同的图像生产方式:

  • 逐笔绘制(串行):如同手写一封信或一本书,画家一笔一画地完成——先画一个圆,再画一个矩形、一条线、若干三角形,直到拼出想要的画面。这是一连串"做完一件再做下一件"的指令。
  • 整页压印(并行):如同印刷机一次把整页内容压到纸上。第一章配图(源自 William Blades 1891 年与 Rolt-Wheeler 1920 年的印刷史插图)直观展示了"逐字母书写"与"整页印刷"的对比:

手写逐字 vs 整页印刷的对比,说明串行与并行两种图像生产方式

Shaders(着色器)也是一组指令,但关键区别在于:这些指令是对屏幕上的每一个像素同时执行的。因此你写的代码必须根据像素在屏幕上的位置表现出不同的行为。像印刷机一样,你的程序本质上是一个"接收位置、返回颜色"的函数;一旦编译完成,它会以极高的速度运行。

换句话说:fragment shader 就是运行在 GPU 上、对**每一个屏幕像素(fragment)**并行执行的小程序。它的输入是像素坐标,输出是颜色,且所有像素共享同一份代码。

中国古代活字印刷,呼应"shader 如同印刷机"的比喻

仓库根目录的 README.md 也给出了全书定位:"This is a gentle step-by-step guide through the abstract and complex universe of Fragment Shaders"——本书面向已有编码经验、具备基础线性代数与三角学知识的创意程序员与游戏开发者。

二、为什么 shader 快:并行处理(Parallel Processing)的威力

要理解 shader 的速度,需要先看清 CPU 的瓶颈。

2.1 CPU 的"工厂管道"模型

把 CPU 想象成一根巨大的工业管道,每个任务都是流过管道的一件物品——就像工厂流水线。任务有大有小,大的任务需要更多时间和能量,也就是需要更多"处理能力"。由于计算机架构的限制,任务被迫串行执行:一件接一件地完成。现代 CPU 通常有 4 个左右的处理器核心,就像几根并行工作的管道(每个管道也称一个 thread,线程):

CPU 串行处理任务的示意图

2.2 像素计算量:一个足以压垮 CPU 的数字

游戏和图形应用需要远超普通程序的算力,因为它们要做海量的逐像素运算:屏幕上每一个像素都要被计算,3D 游戏中还要计算几何与透视。

回到管道与任务的比喻:每个屏幕像素是一个微小任务,单独来看对 CPU 毫无压力——但问题在于这个微小任务要对屏幕上每一个像素重复执行:

  • 老式 800×600 屏幕:每帧 480,000 个像素,按每秒 30 帧折算,就是 每秒 14,400,000 次计算;
  • 现代 2880×1800 Retina 屏、60 帧/秒:每秒计算量高达 311,040,000 次。

这个量级足以让微处理器过载。

2.3 GPU:一大桌并行的小管道

图形工程师的解法就是并行处理:与其拥有几根又大又强的管道(强核 CPU),不如拥有海量同时运行的小型处理器——这正是 GPU(Graphic Processor Unit,图形处理器单元)的架构。第一章配图清晰地展示了 GPU 与 CPU 的硬件差异:

GPU 包含大量并行小型处理器的示意图

把众多微型处理器想象成一大桌管道,把每个像素的数据想象成乒乓球:每秒 14,400,000 个乒乓球足以堵死任何一根管道;但一张 800×600 的管道桌,每秒接收 30 波各 480,000 个乒乓球的洪流,却能流畅应对。分辨率越高,只要并行硬件越多,能处理的流量就越大。

2.4 GPU 的第二项"超能力":硬件加速数学

除了并行,GPU 的另一项超能力是通过硬件直接加速特殊数学函数:复杂的三角函数、矩阵运算直接由微芯片硬件解析完成,而非由软件模拟,速度"快如电流"。这就是为什么后续章节中 sin()、cos()、矩阵乘法等运算在 shader 里几乎不构成性能负担(参见第三章中列出的 sin、cos、tan、pow、fract、clamp 等硬件加速函数)。

三、什么是 GLSL:OpenGL 着色语言

GLSL 全称 OpenGL Shading Language,是本书后续章节将要使用的着色器程序标准。根据硬件和操作系统的不同,还存在其他类型的着色器语言;本书统一采用由 Khronos Group 维护的 OpenGL 规范。理解 OpenGL 的历史有助于理解它许多"奇怪"的约定。由于 GLSL 着色器可以编译运行在多种平台上,你在本书学到的知识可以迁移到任何使用 OpenGL、OpenGL ES 或 WebGL 的环境中——包括 Processing、openFrameworks、Cinder、Three.js 以及 iOS/Android 游戏(参见引言章节)。

四、为什么 shader"出了名的难":盲且无记忆的线程

正如本叔叔所说:"能力越大,责任越大",GPU 强大的并行架构也带来了它的约束:

  1. 线程是"盲"的(blind):为了并行运行,每个管道/线程必须与其他线程完全独立,无法看到其他线程在做什么。所有数据只能单向流动——不可能读取另一个线程的结果、修改输入数据,或把一个线程的输出传递给另一个线程。允许线程间通信会危及数据完整性。
  2. 线程是"无记忆"的(memoryless):GPU 让并行处理器持续忙碌,一旦空闲就接收新任务。一个线程无法知道自己前一瞬间在做什么——它可能刚画完操作系统的 UI 按钮,接着渲染游戏里的一片天空,然后又去显示一封邮件的文字。

正是这种"盲 + 无记忆"的约束,加上"必须把代码抽象成一个随像素位置而变化的通用函数"的要求,让 shader 在初学者中不太受欢迎。但这恰恰也是它的魅力:在 shader 的世界里,没有共享状态,没有顺序依赖,只有"位置 → 颜色"的纯粹映射。

仓库的术语表对上述数据流做了精确注解:uniform 是从 WebGL/OpenGL 环境共享给着色器的只读数据(glossary/uniform);varying 则是从顶点着色器传递到片段着色器、并按顶点插值的数据。

五、第一个 Fragment Shader:Hello World 逐行拆解

GPU 世界里用"Hello world"打印文本对第一步来说过于复杂,于是第二章用一个明亮的颜色来呐喊热情。在浏览器中阅读本书时,代码块是交互式的——得益于 GPU 架构能够"即时编译并替换着色器"(on the fly),你可以点击修改任何代码,改动立刻生效。仓库里的原始文件是 02/hello_world.frag:

#ifdef GL_ES
precision mediump float;
#endif

uniform float u_time;

void main() {
	gl_FragColor = vec4(1.0,0.0,1.0,1.0);
}

虽然这几行代码看似简单,却能推断出大量 GLSL 的核心知识:

  1. 单一入口函数:着色语言只有一个 main() 函数,最终返回一个颜色——这点与 C 语言类似。
  2. 输出变量 gl_FragColor:最终像素颜色被赋给保留全局变量 gl_FragColor。
  3. 内置类型 vec4:这种类 C 语言自带变量(如 gl_FragColor)、函数与类型。vec4 是四维浮点向量;后续还会遇到 vec3、vec2,以及常用的 float、int、bool。
  4. RGBA 通道与归一化:vec4 的四个参数依次对应 R(红)、G(绿)、B(蓝)、A(透明度) 通道,且值是归一化的(范围 0.0 ~ 1.0)。归一化让值在不同变量之间的"映射"变得容易。
  5. 预处理器宏:GLSL 具备 C 风格的预处理器,宏命令以 # 开头,支持 #define 定义与 #ifdef/#endif 条件编译。预编译发生在正式编译之前。示例中只有在 GL_ES 被定义(主要发生在移动设备与浏览器上编译时)才插入第 2 行精度声明。
  6. 浮点精度:浮点类型在 shader 中至关重要,精度档位直接决定渲染速度与画质——精度越低渲染越快,但质量下降。precision mediump float; 将所有浮点设为中等精度;你也可以选用 lowp(低)或 highp(高)。
  7. 没有自动类型转换:GLSL 规范不保证变量会被自动类型转换。硬件厂商对显卡加速流程的实现各不相同,只被强制保证满足最低规格,自动转换不在其中。vec4 是浮点精度,因此期望被赋以浮点数。想写出稳定的代码、避免花几个小时调试白屏,就养成给浮点数加小数点(.)的习惯。下面这种代码不一定能工作:
void main() {
    gl_FragColor = vec4(1,0,0,1);	// ERROR:整数无法可靠地转换为 float
}

动手挑战(源自 第二章)

  • 把浮点换成整数试试——你的显卡可能会容忍这种行为,也可能不会;
  • 注释掉第 8 行,不给函数赋任何像素值,观察结果;
  • 编写一个返回特定颜色的独立函数并在 main() 中调用,例如返回红色的函数:
vec4 red(){
    return vec4(1.0,0.0,0.0,1.0);
}
  • 探索 vec4 的其他构造方式,例如:
vec4 color = vec4(vec3(1.0,0.0,1.0),1.0);

这个例子虽然平淡,却是最基础的一课:我们在把画布内所有像素变成同一种颜色。下一步(第三章)将引入两类输入——空间(像素在屏幕上的位置)与时间(页面加载后的秒数)——来让颜色动起来。

六、让 shader 活起来:uniforms 与 gl_FragCoord

6.1 Uniforms:CPU 与 GPU 之间的"单向小桥"

GPU 管理着大量并行线程,每个线程负责给图像的一小部分上色。虽然线程彼此"盲",我们仍需要能从 CPU 向所有线程发送输入。由于显卡架构的限制,这些输入对所有线程而言必须相等(uniform,一致)且只读——每个线程收到相同的数据,可以读取但无法修改。

这些输入被称为 uniform,支持大部分内置类型:float、vec2、vec3、vec4、mat2、mat3、mat4、sampler2D 和 samplerCube。uniform 在着色器顶部、设定默认浮点精度之后声明(参见第三章):

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2 u_resolution;  // 画布尺寸(宽,高)
uniform vec2 u_mouse;       // 鼠标位置(屏幕像素)
uniform float u_time;       // 自加载以来的秒数

可以把 uniforms 想象成 CPU(主程序)到 GPU(着色器执行处)之间的单向小桥。变量名因实现而异,但本书示例统一传递:

  • u_time:着色器开始运行以来的秒数;
  • u_resolution:绘制着色器的画布(billboard)尺寸;
  • u_mouse:鼠标在画布内的像素位置。

u_ 前缀是作者采用的命名约定,用于明确变量性质。仓库术语表对 uniform 的定义也印证了这一点:"uniform 变量包含从 WebGL/OpenGL 环境共享到顶点或片段着色器的只读数据,值按图元(primitive)保持恒定,适合在整个图元、帧或场景中保持不变的变量"(glossary/uniform/README.md)。

例如,另一个流行的平台 ShaderToy 使用同样的 uniform,只是换了一组名字(iResolution、iMouse、iTime),可见名字只是约定,语义才是本质。

6.2 u_time:让画面动起来

第三章的 time.frag 展示了如何用 u_time 配合正弦函数,让画布中的红色分量随时间波动:

#ifdef GL_ES
precision mediump float;
#endif

uniform float u_time;

void main() {
	gl_FragColor = vec4(abs(sin(u_time)),0.0,0.0,1.0);
}

GLSL 自带硬件加速的角度、三角与指数函数,包括 sin()、cos()、tan()、asin()、acos()、atan()、pow()、exp()、log()、sqrt()、abs()、sign()、floor()、ceil()、fract()、mod()、min()、max()、clamp() 等。

练习建议:放慢频率直到颜色变化几乎不可察觉(例如把 u_time 乘以 0.4);加快直到你看到单一颜色而无闪烁;分别用不同频率驱动 RGB 三个通道,观察有趣的模式。

6.3 gl_FragCoord:线程自己的坐标

正如 GLSL 提供默认输出 vec4 gl_FragColor,它也提供默认输入 vec4 gl_FragCoord——保存当前线程正在处理的像素/屏幕片元的屏幕坐标。它不属于 uniform,因为每个线程的值都不同;gl_FragCoord 被称为 varying(从顶点着色器传递并按顶点插值的变量,见 glossary/varying/README.md)。space.frag 是它的经典用法:

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;

void main() {
	vec2 st = gl_FragCoord.xy/u_resolution;
	gl_FragColor = vec4(st.x,st.y,0.0,1.0);
}

关键技巧是归一化:用 gl_FragCoord.xy 除以画布总分辨率 u_resolution,坐标被映射到 0.0 ~ 1.0 区间,于是可以方便地把 X、Y 值分别映射到红、绿通道——屏幕从左下角(0,0,纯黑)到右上角(1,1,红+绿=黄)呈现一个渐变。

练习与思考(源自第三章):

  • 指出画布中 (0.0, 0.0)、(1.0, 0.0)、(0.0, 1.0)、(0.5, 0.5)、(1.0, 1.0) 各在什么位置;
  • 注意 u_mouse 的单位是像素而非归一化值,思考如何用它移动颜色;
  • 想一个有趣的方式,用 u_time 和 u_mouse 共同改变这个颜色模式。

在 shader 世界里没有太多调试手段,除了"把强颜色赋给变量然后观察",调试有时就像"把船装进瓶子里"——同样艰难、同样美丽、同样有成就感。

七、如何运行你的 shader:从浏览器到三大框架

第四章说明,作者围绕这本书构建了一套在 Linux、macOS、Windows、Raspberry Pi 与浏览器上无需改代码即可一致运行的着色器工具生态,覆盖"展示—创建—分享—策展"四个环节。

7.1 浏览器:glslCanvas

本书所有在线示例均由 glslCanvas 驱动,让运行独立 shader 变得极其简单——只需一个 canvas 元素、class="glslCanvas" 以及 data-fragment-url 指向你的 shader 文件:

<canvas class="glslCanvas" data-fragment-url="yourShader.frag" data-textures="yourInputImage.png" width="500" height="500"></canvas>

仓库首页 README.md 与引言页正是这样嵌入 canvas 的(例如以 data-fragment-url="cmyk-halftone.frag" 和纹理 vangogh.jpg 实时演示 CMYK 半色调滤镜)。

7.2 命令行:glslViewer

glslViewer 让你直接从控制台运行 shader,可以嵌入 bash 脚本或 Unix 管道,用法类似 ImageMagick,同时也是在树莓派上编译 shader 的绝佳方式。基本用法:

glslViewer yourShader.frag yourInputImage.png —w 500 -h 500 -E screenshot,yourOutputImage.png

7.3 在线编辑器:glslEditor

glslEditor 内嵌于本书所有交互示例中,带有一系列小部件,让抽象的 GLSL 编码体验更具体;也可作为独立 Web 应用运行。仓库的 src/main.js 展示了它是如何被挂载到页面上的:页面加载后,脚本遍历所有 .codeAndCanvas 元素,为每个元素创建一个 GlslEditor 实例(配置 canvas_size: 250、canvas_follow: true、tooltips: true、exportIcon: true),并用 editor.open(srcFile) 打开对应 .frag 源码——这正是你阅读本仓库每一章时见到的可编辑画布的实现机制。

7.4 主流框架接入:同一套 uniform 的三种写法

第四章同时给出了在 Three.js、Processing、openFrameworks 中接入 shader 的完整示例(仓库 04/three_js/index.html、04/processing/processing.pde、04/openFrameworks 提供全部源码)。

Three.js(HTML + JS,注意 id="fragmentShader" 的 script 里可以粘贴本书的所有 shader):

<script id="fragmentShader" type="x-shader/x-fragment">
    uniform vec2 u_resolution;
    uniform float u_time;

    void main() {
        vec2 st = gl_FragCoord.xy/u_resolution.xy;
        gl_FragColor=vec4(st.x,st.y,0.0,1.0);
    }
</script>

并在初始化时构造 uniforms 对象、在 render() 中用 clock.getDelta() 累加 u_time,用 onWindowResize 更新 u_resolution:

uniforms = {
    u_time: { type: "f", value: 1.0 },
    u_resolution: { type: "v2", value: new THREE.Vector2() },
    u_mouse: { type: "v2", value: new THREE.Vector2() }
};

Processing(P2D 渲染器 + loadShader,每次 draw() 通过 shader.set() 传入三个 uniform;shader.frag 需放在 sketch 的 data 目录;2.1 之前的版本需在 shader 开头加 #define PROCESSING_COLOR_SHADER):

PShader shader;

void setup() {
  size(640, 360, P2D);
  noStroke();
  shader = loadShader("shader.frag");   // 从 data 目录加载并编译
}

void draw() {
  shader.set("u_resolution", float(width), float(height));
  shader.set("u_mouse", float(mouseX), float(mouseY));
  shader.set("u_time", millis() / 1000.0);
  shader(shader);                        // 用我们的 shader 替换默认管线
  rect(0,0,width,height);                // 绘制画布(billboard)
}

仓库的 04/processing/processing.pde 还额外演示了按任意键热重载 shader 的小技巧(keyPressed() 中重新 loadShader)。

openFrameworks(C++,ofShader 同样从 data 目录加载 .frag):

void ofApp::draw(){
    ofShader shader;
    shader.load("","shader.frag");

    shader.begin();
    shader.setUniform1f("u_time", ofGetElapsedTimef());
    shader.setUniform2f("u_resolution", ofGetWidth(), ofGetHeight());
    ofRect(0,0,ofGetWidth(), ofGetHeight());
    shader.end();
}

7.5 从源码看本书的交互机制

除了 main.js 中 GlslEditor 的挂载逻辑,仓库 00/cmyk-halftone.frag 是一份非常值得研读的真实生产级 shader:它完整演示了本章与后续章节概念的综合运用——声明 uniform sampler2D u_tex0(纹理输入)、uniform vec2 u_resolution/u_mouse/u_time,用 gl_FragCoord.xy/u_resolution.xy 归一化坐标,再用 smoothstep、mod、texture2D、旋转矩阵 mat2 等实现 CMYK 半色调效果。它证明了"位置→颜色"的函数模型可以驱动多么复杂的图像处理算法,也印证了引言中"第二张图由青、品红、黄、黑四组像素矩阵非串行(同时)合成"的说法。

八、总结与下一步

本章是全书的第一块基石,核心结论可以浓缩为三点:

  1. Fragment shader 是运行在 GPU 上的像素级并行函数:接收位置、返回颜色,对屏幕上每个像素同时执行;
  2. 它的快来自并行硬件与硬件加速数学:大量小型处理器同时吞吐像素流,三角函数与矩阵运算由芯片直接解析;
  3. 它的难来自约束:线程"盲"且"无记忆",数据单向流动,没有自动类型转换,因此需要把程序抽象成随位置变化的通用函数。

沿着本仓库的章节地图(见 README.md 的目录),下一步是:

  • 第二章 "Hello world!":在交互式编辑器中亲手修改你的第一个 shader;
  • 第三章 Uniforms:用 u_time、u_resolution、u_mouse 让画面随时间与鼠标运动;
  • 第四章 Running your shader:把 shader 跑进 Three.js、Processing 与 openFrameworks;
  • 之后的章节将依次深入形状函数、色彩、矩阵、噪声、分形布朗运动、图像处理与光线步进(Ray Marching)等进阶主题。

如果你现在正用现代浏览器阅读本仓库对应的在线版本,每个代码块都是可交互的——把代码改起来,让概念动起来,这就是学习 shader 最快的方式。

登录后查看全文
thebookofshaders