从 JavaScript 到 GLSL:强类型、向量与 Fragment Shader 编程入门指南

原创2026-10-15 09:42:051,457 阅读

从 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 开发环境,正式开启着色器之旅。

登录后查看全文
thebookofshaders