从 JavaScript 到 GLSL:强类型、向量与 Fragment Shader 编程入门指南
从 JavaScript 到 GLSL:强类型、向量与 Fragment Shader 编程入门指南
本指南面向从 JavaScript(以及 Canvas API)转向 GLSL 的开发者,系统讲解二者在语言模型上的根本差异,并逐一拆解 GLSL 的强类型体系、向量数据结构、类型转换、构造函数、循环与条件、限定符(uniform / const / in / out / inout)以及坐标系等核心概念。读完本文,你将能够读懂 The Book of Shaders 仓库中各章节的 .frag 示例(例如 03/space.frag 与 05/linear.frag),理解 fragment shader 的写法与常见套路,为后续动手创作着色器打下基础。
JavaScript 开发者遇到的第一个意外:解释型与编译型的本质差异
如果你是 JavaScript 开发者,阅读本书时会感到些许惊讶:操作高层 JS 与编写 shader 之间存在许多不同。不过,与底层的汇编语言相比,GLSL 仍然是人类可读的,只要接受它的特性,很快就能上手。
最核心的差异在于:JavaScript 是解释型(interpreted)语言,而 GLSL 是编译型(compiled)语言。
- 编译型程序直接运行在操作系统(或目标平台)上,层级低、通常很快;
- 解释型程序需要依赖一个虚拟机(Virtual Machine,VM)才能执行,层级高、通常较慢。
以浏览器为例:当浏览器(即 JavaScript 的 VM)运行或解释一段 JS 时,它事先并不知道哪个变量是什么类型、哪个函数做了什么(值得注意的例外是 TypedArrays)。因此它无法提前做任何优化,只能先花时间读取你的代码、从使用方式中推断(infer)变量的类型,然后在可能的情况下,将部分代码转换为运行更快的汇编代码。这是一条缓慢、费力且复杂的过程——如果你对细节感兴趣,可以研究 Chrome V8 引擎的工作方式。更麻烦的是,每个浏览器都以自己的方式优化 JS,且这个过程对开发者是隐藏的,你几乎无能为力。
相比之下,编译型程序不会被逐行解释:编译器在运行前就会检查整个程序,代码合法才通过编译。这带来一个立竿见影的变化——如果你忘了在行尾写分号,你的代码就是非法的,根本无法编译成可运行的程序。这看起来很"冷酷",但这正是 shader 的本质:一个在 GPU 上运行的编译程序。
好消息是,编译器是你最好的朋友,它会明确告诉你程序在哪里、为什么编译失败,修正后 shader 会在就绪时立刻显示出来。本书的配套编辑器(本书网站内嵌的着色器编辑环境)非常用户友好,因为 shader 可视化程度高,即使写错也几乎不会"搞坏任何东西",是绝佳的学习方式。
shader 由两个程序组成
一个 shader 由两个程序组成:vertex shader(顶点着色器) 和 fragment shader(片元着色器)。
- vertex shader(第一个程序):以 几何体(geometry) 为输入,将其转换为一系列 像素(或 fragment);
- fragment shader(第二个程序):接收这些 fragment,决定每个像素最终被涂成什么颜色。
本书绝大部分内容聚焦于后者。在仓库的所有示例中,几何体都是一个覆盖整个屏幕的简单四边形(billboard),因此 fragment shader 中的坐标可以直接与屏幕位置对应。
强类型:告别 var,拥抱标量类型
如果你来自 JS 或其他无类型语言,给你的变量(以及函数)标注类型(typing) 是一个陌生的概念,这往往是迈向 GLSL 最难的一步。所谓 tipleme(土耳其语,即"类型标注"),顾名思义就是为变量和函数显式指定类型。这意味着:var 关键字在 GLSL 中根本不存在。
不再使用万能的 var,你必须在声明每个变量时明确指出其类型。这样编译器只会看到它知道如何高效处理的对象和基本类型。代价是你需要了解所有可用的类型——好在它们数量不多、相当简单(GLSL 不是一个 Java 框架)。
其实这和写 JS 时的直觉差异并不大:如果一个变量是 boolean,你自然会期望它只存 true 或 false;如果变量命名为 var uid = XXX;,你大概率会往里存整数;而 var y = YYY; 可能引用一个浮点值。强类型的好处是,你不再需要浪费时间纠结 X == Y 还是 typeof X == typeof Y 之类的判断——你知道类型,即使你不知道,编译器也知道。
GLSL 中的标量类型(scalar types)(标量即描述一个数量的量)有以下三种:
// 布尔值:
JS: var b = true; GLSL: bool b = true;
// 整数值:
JS: var i = 1; GLSL: int i = 1;
// 浮点值(即 JS 中的 Number):
JS: var f = 3.14159; GLSL: float f = 3.14159;
声明类型本身并不难,反而省去了运行时检查类型的时间。每当你产生怀疑时,记住:这样做的目的是让你的程序比 JS 快得多。
void
存在一个大致对应 JS null 概念的 void 类型,它用作不返回任何值的方法的返回类型。你不能把它赋值给变量。
boolean 与条件分支的并行性陷阱
布尔值主要用于条件测试,如 if( myBoolean == true ){}else{}。虽然条件分支在 CPU 上是合法选项,但 GLSL 的并行本质(同一段代码在成千上万个 fragment 上同时执行)使得大量使用条件分支不那么合适。因此,条件语句的使用在本书中常常不被推荐,书中后续章节会介绍若干替代技术(例如用 mix()、step()、smoothstep() 等函数做数值化混合,而不是用 if/else 走两条不同的计算路径)。
类型转换(type casting)
GLSL 不允许不同类型变量之间直接运算。例如:
int i = 2;
float f = 3.14159;
// 试图用一个整数乘以一个浮点数
float r = i * f;
这样无法正常编译,因为这相当于试图"把一只猫和一只长颈鹿杂交"。解决办法是使用类型转换——它并不真正改变 i 的类型,而是让编译器相信 i 是 float 类型:
// 将整型变量 'i' 转换为 float 类型
float r = float( i ) * f;
这相当于"给猫穿上一件长颈鹿戏服",结果符合预期:r 将保存 i 与 f 相乘的结果。
可以把上述任一类型转换为其他任何类型,但要注意转换规则:
float转int的行为类似Math.floor(),会丢弃小数点后的值;float或int转bool时,只要变量不为零就返回true。
类型即构造函数
变量的类型同时也是它自己的类构造函数:一个 float 变量可以视为 Float 类的一个实例。以下定义完全等价且都合法:
int i = 1;
int i = int( 1 );
int i = int( 1.9995 );
int i = int( true );
对标量类型而言,这种写法与类型转换差别不大,但当你接触到 重载(overload) 时会发现它真正的意义。
向量:GLSL 内置的复合数据结构
和 JS 一样,GLSL 也需要更复杂的方式来组织数据,这就是向量(vector) 的用武之地。假设你在 JS 中为了同时保存一个 x 和 y 值而写了一个 Point 类:
// '类' 定义:
var Point = function( x, y ){
this.x = x || 0;
this.y = y || 0;
}
// 然后这样实例化:
var p = new Point( 100,100 );
用刚学到的眼光看,这段代码在很多层面上都是"错的":那个 var 关键字、可怕的 this、无类型的 x 和 y……这在 shader 世界是行不通的。
GLSL 提供了内置数据结构来打包数据:
bvec2:2D 布尔向量;bvec3:3D 布尔向量;bvec4:4D 布尔向量ivec2:2D 整型向量;ivec3:3D 整型向量;ivec4:4D 整型向量vec2:2D 浮点向量;vec3:3D 浮点向量;vec4:4D 浮点向量
你大概已经发现了:每种基础类型都对应一组向量。于是 bvec2 保存两个 bool 值,vec4 保存四个 float 值。
向量引入的另一个概念是维度(dimension)——它并不表示"2D 渲染用 2D 向量、3D 渲染用 3D 向量"。那么 4D 向量表示什么?不,维度表示向量中存储的 分量(component) 的个数和类型:
// 创建一个 2D 布尔向量
bvec2 b2 = bvec2 ( true, false );
// 创建一个 3D 整型向量
ivec3 i3 = ivec3( 0,0,1 );
// 创建一个 4D 浮点向量
vec4 v4 = vec4( 0.0, 1.0, 2.0, 1. );
b2 保存两个布尔值,i3 保存三个整数值,v4 保存四个浮点值。对标量来说取值一目了然(float f = 1.2; 之后 f 就是 1.2),而对向量而言取值方式有些特别,也相当优雅。
访问器(accessors):xyzw、rgba、stpq 与下标
假设创建了 vec4 v4 = vec4( 0.0, 1.0, 2.0, 3.0 );,取这四个值可以这样写:
float x = v4.x; // x = 0.0
float y = v4.y; // y = 1.0
float z = v4.z; // z = 2.0
float w = v4.w; // w = 3.0
但下面的写法同样完全合法:
float x = v4.x = v4.r = v4.s = v4[0]; // x = 0.0
float y = v4.y = v4.g = v4.t = v4[1]; // y = 1.0
float z = v4.z = v4.b = v4.p = v4[2]; // z = 2.0
float w = v4.w = v4.a = v4.q = v4[3]; // w = 3.0
你可以注意到三件事:
X、Y、Z、W用于 3D 编程中表示 3D 向量;R、G、B、A用于编码颜色及其 alpha 值;[0]、[1]、[2]、[3]表明向量是支持随机访问的值数组。
因此,根据你是在处理 2D/3D 坐标、带或不带 alpha 的颜色,还是只是若干随机变量,可以选择最合适的向量类型与维度。通常 2D 坐标与几何向量用 vec2/vec3/vec4 保存,颜色在需要透明度时用 vec3 或 vec4 保存,但对向量的使用并无严格限制——例如你完全可以在 bvec4 里只存一个布尔值,只是浪费内存而已。
注意:在 shader 中,颜色值(R、G、B、A)是归一化的,范围在 0 到 1 之间,而不是 0 到 0xFF(255),所以保存颜色最好用浮点 vec4 而不是整型 ivec4。这一点在仓库大量示例中体现:例如 06/hsb.frag 中 hsb2rgb() 返回的 vec3 颜色分量全部落在 [0,1] 区间。
swizzle:一次性取多个分量
你可以同时取出多个值。假设只需要某个 vec4 的 X 和 Y 分量,在 JS 中你大概要写:
var needles = [0, 1]; // 数据结构中 'x' 与 'y' 的位置
var a = [ 0,1,2,3 ]; // 相当于我们的 'vec4'
var b = [ a[ needles[ 0 ] ], a[ needles[ 1 ] ] ]; // b = [ 0, 1 ]
这很丑陋。在 GLSL 中只需:
// 创建 4D 浮点向量
vec4 v4 = vec4( 0.0, 1.0, 2.0, 3.0 );
// 只取 X 和 Y 分量
vec2 xy = v4.xy; // xy = vec2( 0.0, 1.0 );
当你组合访问器时,GLSL 会优雅地以最合适的向量格式返回你想要的值子集。向量本质上就是 JS 中数组那样的随机访问数据结构。你不仅可以取子集,还能指定你需要的顺序,这可以用来反转向量分量的值:
// 创建 4D 浮点向量:R,G,B,A
vec4 color = vec4( 0.2, 0.8, 0.0, 1.0 );
// 按 A,B,G,R 的顺序取颜色分量
vec4 backwards = color.abgr; // backwards = vec4( 1.0, 0.0, 0.8, 0.2 );
当然,你甚至可以多次请求同一个分量:
// 创建 4D 浮点向量:R,G,B,A
vec4 color = vec4( 0.2, 0.8, 0.0, 1.0 );
// 基于颜色的 G 与 A 通道得到一个 GAG 的 vec3
vec3 GAG = color.gag; // GAG = vec4( 0.8, 1.0, 0.8 );
swizzle 对拼接向量片段、提取 RGBA 颜色的 rgb 通道等操作极为实用。例如 06/hsb.frag 中的 vec4(c.bg, K.wz) 正是利用 swizzle 重组颜色通道的实例。
重载(overload):运算符与构造函数
重载是指根据操作数/参数来改变运算符或函数的行为。JavaScript 不允许重载,所以初看会觉得奇怪;但习惯之后你会好奇为什么 JS 不这么做(简短的回答是:类型推断)。
运算符重载最基础的例子:
vec2 a = vec2( 1.0, 1.0 );
vec2 b = vec2( 1.0, 1.0 );
// 重载的加法
vec2 c = a + b; // c = vec2( 2.0, 2.0 );
对,非数字的东西也能相加!这适用于所有运算符(+、-、*、/),但这只是开始。看看下面的片段:
vec2 a = vec2( 0.0, 0.0 );
vec2 b = vec2( 1.0, 1.0 );
// 重载的构造函数
vec4 c = vec4( a , b ); // c = vec4( 0.0, 0.0, 1.0, 1.0 );
我们从两个 vec2 构造出一个 vec4:新的 vec4 把 a.x、a.y 作为 c 的 X、Y 分量,再把 b.x、b.y 作为 c 的 Z、W 分量。这正是函数针对不同参数被重载的例子——这里的 vec4 构造函数可接受多种签名组合,以下所有定义都合法:
vec4 a = vec4(1.0, 1.0, 1.0, 1.0);
vec4 a = vec4(1.0);// x, y, z, w 全部等于 1.0
vec4 a = vec4( v2, float, v4 );// vec4( v2.x, v2.y, float, v4.x );
vec4 a = vec4( v3, float );// vec4( v3.x, v3.y, v3.z, float );
// 等等
唯一需要注意的是:要提供足够的参数来"填满"你的向量。最后,你也可以在程序中重载内置函数以接受它们原本没设计的参数(不过这种情况不应太频繁)。
其他类型:数组与 struct
除向量外还有矩阵(mat2/mat3/mat4)和纹理采样器(sampler2D/samplerCube)等基础类型,本书后续章节会涉及。此外还可以使用数组,当然它们必须带类型,并且有一些"怪癖":
- 大小是固定的;
- 不能
push()、pop()、splice()等,也没有length属性; - 不能直接用值列表初始化;
- 必须逐元素赋值。
所以这样不合法:
int values[3] = [0,0,0];
但这样合法:
int values[3];
values[0] = 0;
values[1] = 0;
values[2] = 0;
当你事先知道数据量、或只有少量值时,这样够用。若想要更具表达力的变量定义方式,可以使用 struct 类型——它类似于没有方法的对象,允许在同一对象中保存并访问多个变量:
struct ColorStruct {
vec3 color0;
vec3 color1;
vec3 color2;
}
然后这样初始化并访问:
// 用一些值初始化结构体
ColorStruct sandy = ColorStruct( vec3(0.92,0.83,0.60),
vec3(1.,0.94,0.69),
vec3(0.95,0.86,0.69) );
// 从结构体中访问某个值
sandy.color0 // vec3(0.92,0.83,0.60)
这只是语法糖,但能帮你写出更干净、更接近你熟悉风格的代码。
语句与条件:if、for、break、continue
数据结构本身很美好,但迟早你需要迭代或做条件测试。幸运的是,语法与 JavaScript 非常接近。
条件语句的写法:
if( condition ){
// 为真
}else{
// 为假
}
for 循环通常这样写(整数迭代器):
const int count = 10;
for( int i = 0; i <= count; i++){
// 做点什么
}
也可以用浮点迭代器:
const float count = 10.;
for( float i = 0.0; i <= count; i+= 1.0 ){
// 做点什么
}
注意 count 必须定义为常量(const)——即在类型前加 const 限定符(下一节详述)。我们还有 break 和 continue:
const float count = 10.;
for( float i = 0.0; i <= count; i+= 1.0 ){
if( i < 5. )continue;
if( i >= 8. )break;
}
仓库示例中对这两种循环形式都有实际运用:例如 09/iching-01.frag 使用 for(int i = 0; i < 6; i++) 遍历六爻,而 10/ikeda-digits.frag 使用 for(float i = 0.0; i < 25.0; i++) 做浮点步进迭代。
注意:在某些硬件上 break 可能不按预期工作,循环不会提前退出。总体原则是:尽可能把迭代次数压到最低,并尽可能避免循环与条件语句——因为 fragment shader 的每一条指令都会在成千上万个并行线程上重复执行。
限定符(qualifiers):uniform、const 与 in/out/inout
在变量类型之上,GLSL 还使用限定符来帮助编译器判断"哪个变量是什么"。例如,有些数据只能从 CPU 提供给 GPU,它们被称为 attribute 和 uniform:
- attribute:保留给 vertex shader 使用;
- uniform:vertex shader 与 fragment shader 中都可以使用;
- varying:用于在 vertex 与 fragment shader 之间传递变量。
本书主要聚焦 fragment shader,因此你更多会看到类似这样的声明:
uniform vec2 u_resolution;
注意:我们在变量类型之前加上了 uniform 限定符。这表示当前画布(billboard)的分辨率由 CPU 传入 shader——画布宽度存在 2D 向量的 x 分量中,高度存在 y 分量中。当编译器看到带 uniform 限定的变量时,它会确保你在运行时无法修改这些值(只读)。
仓库中几乎每一个 .frag 示例的开头都遵循这一约定,例如 03/space.frag:
#ifdef GL_ES
precision mediump float;
#endif
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
关于这些 uniform 的语义,03/README.md 有专门说明:u_time(shader 启动以来经过的秒数)、u_resolution(绘制 shader 的画布尺寸)、u_mouse(鼠标在画布内的像素坐标),并遵循"uniform 名前加 u_"的命名约定。不同实现会使用不同名字,例如 ShaderToy 对应为 iResolution、iMouse、iTime。
for 循环的边界 count 也是如此:
const float count = 10.;
for( ... )
使用 const 限定符后,编译器会确保你只能给变量赋一次值,否则它就不是常量了。
函数签名中还有三个额外的限定符:in、out 和 inout。在 JavaScript 中,向函数传入标量参数时,值只读——即使在函数内部修改,函数外部的变量也不受影响:
function banana( a ){
a += 1;
}
var value = 0;
banana( value );
console.log( value );// > 0 ; 修改在函数外部不生效
借助参数限定符,你可以明确指定参数的行为:
in:只读(默认值)out:只写——你不能读取该参数的值,但可以设置它inout:可读可写——既能读取也能设置该变量的值
在 GLSL 中重写 banana 方法如下:
void banana( inout float a ){
a += 1.;
}
float A = 0.;
banana( A ); // 现在 A = 1.;
这与 JS 非常不同,而且相当强大。当然你并非必须指定签名限定符(默认就是只读的 in)。
空间与坐标:Y 轴向上、原点在左下
最后一个重要提醒:在 DOM 和 Canvas 2D 中,Y 轴指向"下方"。这在 DOM 语境下是合理的,因为它遵循网页的展开方式——导航栏在上,内容向下扩展。而在 WebGL 画布中,Y 轴是翻转的:Y 指向"上方"。
这意味着原点 (0,0) 位于 WebGL 上下文的左下角,而不是 2D Canvas 的左上角。纹理坐标遵循同样的规则,一开始可能不太直观。
仓库示例中的标准做法是先把片元坐标归一化,例如 03/space.frag 中的:
vec2 st = gl_FragCoord.xy/u_resolution;
gl_FragCoord 保存当前线程正在处理的像素(屏幕 fragment)坐标,除以 u_resolution 后得到范围 0.0 ~ 1.0 的归一化坐标 st,便于把 X、Y 映射到红、绿通道。这一惯用法几乎出现在仓库的每个示例中(见 05/linear.frag、07/circle-making.frag 等),理解了"原点在左下、Y 向上、坐标归一化到 0-1"这三件事,你就能读懂绝大多数 fragment shader 的坐标逻辑。
总结
本文(对应仓库 appendix/04/README-tr.md 的完整内容)是一份面向 JS 开发者的"拥抱式入门":编译型与解释型的差异解释了为什么 shader 需要显式类型与谨慎的流程控制;强类型、类型转换与构造函数构成 GLSL 的基础语法;向量、swizzle 与重载提供了高效的数据组织与运算手段;uniform/const/in/out/inout 限定符刻画了 CPU 与 GPU 之间、函数内外的数据流动规则;而坐标系的差异则是写出正确 shader 的前提。有了这些基础,你就可以进入仓库 04 章节,学习如何在 three.js、Processing、openFrameworks 等工具中搭建自己的 shader 开发环境,正式开启着色器之旅。