🎮 3D图形开发 - GLSL

What is GLSL? What role does it play in the graphics rendering pipeline?

考察点：GLSL基础概念。

答案：

GLSL（OpenGL Shading Language）是OpenGL的官方着色器语言，用于在GPU上编写可编程渲染管线程序。它是一种类C语言，专门设计用于图形处理，允许开发者直接控制顶点处理和像素着色过程，实现各种复杂的视觉效果。

核心特点：

• GPU执行：着色器代码在图形处理器上并行执行，性能极高
• 类C语法：语法类似C语言，易于学习和使用
• 强类型系统：严格的类型检查，内置向量和矩阵类型
• 实时渲染：每帧执行数百万次，实现动态视觉效果

在渲染管线中的位置：

1. 顶点着色器阶段：处理每个顶点的位置变换、法线计算等
2. 几何着色器阶段（可选）：生成新的几何图元
3. 片段着色器阶段：计算每个像素的最终颜色
4. 光栅化之间：在固定管线阶段之间插入可编程逻辑

主要作用：

// 顶点着色器示例
attribute vec3 position;
uniform mat4 projectionMatrix;
uniform mat4 modelViewMatrix;

void main() {
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

// 片段着色器示例
precision mediump float;
uniform vec3 color;

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

实际应用：

• 材质效果：金属、玻璃、布料等真实材质模拟
• 光照计算：实时光照、阴影、反射等效果
• 后期处理：景深、辉光、色彩校正等屏幕特效
• 程序化生成：噪声纹理、动态图案、粒子效果

What are the versions of GLSL? What are the main differences between different versions?

考察点：GLSL版本演进。

答案：

GLSL版本与OpenGL/WebGL版本紧密相关，每个版本都引入了新特性和语法改进。版本号通常以三位数字表示（如110、330、450），对应OpenGL版本的主次版本号。

主要版本对比：

1. GLSL 1.10-1.20（OpenGL 2.0-2.1）

// 使用attribute和varying关键字
attribute vec3 position;
varying vec2 vUv;

void main() {
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

2. GLSL 1.30-1.50（OpenGL 3.0-3.2）

• 引入in和out关键字替代attribute和varying
• 支持整数类型和位运算
• 增加纹理查找函数

#version 130
in vec3 position;
out vec2 vUv;

void main() {
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

3. GLSL 3.30+（OpenGL 3.3+）

• 明确的输入输出布局
• 支持多个渲染目标
• uniform块和缓冲对象

#version 330 core
layout(location = 0) in vec3 position;
layout(location = 1) in vec2 uv;
out vec2 vUv;

void main() {
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

4. GLSL ES（WebGL）

• GLSL ES 1.00（WebGL 1.0）：基于GLSL 1.20
• GLSL ES 3.00（WebGL 2.0）：基于GLSL 3.30

// WebGL 1.0
precision mediump float;
attribute vec3 position;
varying vec2 vUv;

// WebGL 2.0
#version 300 es
precision mediump float;
in vec3 position;
out vec2 vUv;

版本选择建议：

• WebGL项目：使用GLSL ES 1.00或3.00
• 桌面应用：使用GLSL 3.30+以获得最佳特性
• 兼容性优先：使用GLSL 1.20或GLSL ES 1.00
• 移动端：优先使用GLSL ES 1.00，确保广泛兼容

What is the basic structure of a GLSL program? How to write the simplest shader?

考察点：着色器程序结构。

答案：

GLSL程序由顶点着色器和片段着色器组成，两者协同工作完成图形渲染。每个着色器都必须包含一个main()函数作为入口点，通过变量限定符实现数据传递。

基本结构组成：

1. 版本声明（可选但推荐）
2. 精度声明（WebGL必需）
3. 变量声明（uniform、attribute/in、varying/out）
4. main函数（程序入口）
5. 辅助函数（可选）

最简单的着色器示例：

// 顶点着色器 - 最简版本
attribute vec3 position;

void main() {
    gl_Position = vec4(position, 1.0);
}

// 片段着色器 - 最简版本
precision mediump float;

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

完整结构示例：

// 顶点着色器 - 完整版本
#version 300 es
precision highp float;

// 输入变量
in vec3 position;
in vec3 normal;
in vec2 uv;

// Uniform变量
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

// 输出到片段着色器
out vec3 vNormal;
out vec2 vUv;
out vec3 vPosition;

void main() {
    vNormal = normal;
    vUv = uv;
    
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vPosition = worldPosition.xyz;
    
    gl_Position = projectionMatrix * viewMatrix * worldPosition;
}

// 片段着色器 - 完整版本
#version 300 es
precision mediump float;

// 从顶点着色器接收
in vec3 vNormal;
in vec2 vUv;
in vec3 vPosition;

// Uniform变量
uniform vec3 lightPosition;
uniform vec3 cameraPosition;
uniform sampler2D diffuseTexture;

// 输出
out vec4 fragColor;

void main() {
    // 纹理采样
    vec4 texColor = texture(diffuseTexture, vUv);
    
    // 简单光照计算
    vec3 normal = normalize(vNormal);
    vec3 lightDir = normalize(lightPosition - vPosition);
    float diff = max(dot(normal, lightDir), 0.0);
    
    vec3 finalColor = texColor.rgb * diff;
    fragColor = vec4(finalColor, texColor.a);
}

关键要点：

• main函数：每个着色器必须有且只有一个main函数
• 内置变量：gl_Position（顶点）、gl_FragColor（片段）
• 变量传递：通过varying/in-out在着色器间传递数据
• 精度声明：WebGL中必须声明浮点精度

What is the compilation and linking process in GLSL?

考察点：着色器编译机制。

答案：

GLSL着色器的编译和链接是在运行时由WebGL/OpenGL驱动程序完成的，不同于传统的预编译语言。这个过程包括源码编译、着色器链接和程序验证三个主要阶段。

编译和链接流程：

1. 创建着色器对象

// WebGL环境中
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);

2. 加载着色器源码

const vertexSource = `
    attribute vec3 position;
    void main() {
        gl_Position = vec4(position, 1.0);
    }
`;

const fragmentSource = `
    precision mediump float;
    void main() {
        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
    }
`;

gl.shaderSource(vertexShader, vertexSource);
gl.shaderSource(fragmentShader, fragmentSource);

3. 编译着色器

gl.compileShader(vertexShader);
gl.compileShader(fragmentShader);

// 检查编译错误
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    console.error('顶点着色器编译错误:', gl.getShaderInfoLog(vertexShader));
}

4. 创建程序对象

const program = gl.createProgram();

5. 附加着色器

gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);

6. 链接程序

gl.linkProgram(program);

// 检查链接错误
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    console.error('程序链接错误:', gl.getProgramInfoLog(program));
}

7. 使用程序

gl.useProgram(program);

完整示例：

function createShaderProgram(gl, vertexSource, fragmentSource) {
    // 编译顶点着色器
    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
    
    // 编译片段着色器
    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
    
    // 链接程序
    const program = gl.createProgram();
    gl.attachShader(program, vertexShader);
    gl.attachShader(program, fragmentShader);
    gl.linkProgram(program);
    
    // 验证程序
    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
        const info = gl.getProgramInfoLog(program);
        throw new Error('程序链接失败: ' + info);
    }
    
    // 清理着色器对象（可选）
    gl.deleteShader(vertexShader);
    gl.deleteShader(fragmentShader);
    
    return program;
}

function compileShader(gl, type, source) {
    const shader = gl.createShader(type);
    gl.shaderSource(shader, source);
    gl.compileShader(shader);
    
    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
        const info = gl.getShaderInfoLog(shader);
        gl.deleteShader(shader);
        throw new Error('着色器编译失败: ' + info);
    }
    
    return shader;
}

常见编译错误：

• 语法错误：拼写错误、缺少分号等
• 类型不匹配：变量类型转换错误
• 未声明变量：使用了未定义的变量
• 精度未指定：WebGL中未声明float精度
• 版本不兼容：使用了当前版本不支持的特性

调试技巧：

• 检查gl.getShaderInfoLog()获取详细错误信息
• 使用gl.validateProgram()验证程序状态
• 分段注释代码定位错误位置
• 使用浏览器开发工具的WebGL调试扩展

What are the basic data types in GLSL? What are their characteristics?

考察点：基础数据类型。

答案：

GLSL提供了丰富的数据类型系统，包括标量类型、向量类型、矩阵类型和采样器类型。这些类型专门为图形计算优化，支持高效的并行处理。

标量类型：

// 浮点数
float a = 1.0;
float b = 1.5e-3; // 科学计数法

// 整数
int count = 10;
int negative = -5;

// 无符号整数（GLSL 1.30+）
uint index = 0u;

// 布尔值
bool isVisible = true;
bool flag = false;

向量类型：

// 浮点向量
vec2 position = vec2(1.0, 2.0);          // 2D向量
vec3 color = vec3(1.0, 0.5, 0.0);        // 3D向量/RGB
vec4 vertex = vec4(0.0, 1.0, 0.0, 1.0);  // 4D向量/RGBA

// 整数向量
ivec2 pixel = ivec2(100, 200);
ivec3 indices = ivec3(0, 1, 2);
ivec4 data = ivec4(1, 2, 3, 4);

// 布尔向量
bvec2 flags = bvec2(true, false);
bvec3 mask = bvec3(false, true, false);
bvec4 test = bvec4(true);

// 向量构造方式
vec3 v1 = vec3(1.0);                // (1.0, 1.0, 1.0)
vec3 v2 = vec3(1.0, 2.0, 3.0);      // (1.0, 2.0, 3.0)
vec4 v3 = vec4(v2, 4.0);            // (1.0, 2.0, 3.0, 4.0)
vec4 v4 = vec4(vec2(1.0, 2.0), vec2(3.0, 4.0)); // (1.0, 2.0, 3.0, 4.0)

矩阵类型：

// 浮点矩阵
mat2 rotation = mat2(1.0, 0.0, 0.0, 1.0);    // 2x2矩阵
mat3 transform = mat3(1.0);                   // 3x3单位矩阵
mat4 mvp = mat4(1.0);                         // 4x4单位矩阵

// 非方阵（GLSL 1.20+）
mat2x3 m23 = mat2x3(1.0);  // 2列3行
mat3x4 m34 = mat3x4(1.0);  // 3列4行

// 矩阵构造
mat3 m = mat3(
    1.0, 0.0, 0.0,  // 第一列
    0.0, 1.0, 0.0,  // 第二列
    0.0, 0.0, 1.0   // 第三列
);

采样器类型：

// 2D纹理采样器
uniform sampler2D diffuseMap;
uniform sampler2D normalMap;

// 立方体贴图采样器
uniform samplerCube envMap;

// 3D纹理采样器
uniform sampler3D volumeTexture;

// 阴影采样器
uniform sampler2DShadow shadowMap;

类型特点：

1. 强类型系统

float a = 1.0;
int b = 1;
// float c = a + b;  // 错误：类型不匹配
float c = a + float(b);  // 正确：显式转换

2. 向量分量访问

vec4 color = vec4(1.0, 0.5, 0.0, 1.0);

// 通过xyz/rgba/stpq访问
float r = color.r;  // 或 color.x 或 color.s
float g = color.g;  // 或 color.y 或 color.t
vec3 rgb = color.rgb;
vec2 rg = color.rg;

// Swizzle操作
vec4 swizzled = color.bgra;  // (0.0, 0.5, 1.0, 1.0)
vec3 repeated = color.rrr;   // (1.0, 1.0, 1.0)

3. 矩阵列主序

mat3 m = mat3(1.0, 2.0, 3.0,  // 第一列
              4.0, 5.0, 6.0,  // 第二列
              7.0, 8.0, 9.0); // 第三列

// 访问元素
float value = m[0][1];  // 第一列第二行 = 2.0

类型转换规则：

// 显式转换
int i = 5;
float f = float(i);      // 5.0

float f2 = 3.7;
int i2 = int(f2);        // 3（截断）

// 向量转换
vec3 v3 = vec3(1.0, 2.0, 3.0);
vec4 v4 = vec4(v3, 4.0);     // 扩展
vec2 v2 = v3.xy;             // 收缩

// 不允许隐式转换
// vec3 wrong = vec3(1, 2, 3);  // 错误
vec3 correct = vec3(1.0, 2.0, 3.0);  // 正确

实际应用：

• 位置计算：使用vec3/vec4存储坐标
• 颜色处理：使用vec3(RGB)或vec4(RGBA)
• 变换矩阵：使用mat4进行MVP变换
• 纹理采样：使用sampler2D获取纹理颜色

What are the vector types in GLSL? How to access vector components?

考察点：向量类型和swizzle操作。

答案：

GLSL的向量类型是图形计算的核心数据结构，支持2、3、4维向量，并提供灵活的分量访问方式（Swizzling）。向量运算在GPU上高度优化，可以并行执行，是着色器编程的基础。

向量类型分类：

// 浮点向量（最常用）
vec2 texCoord = vec2(0.5, 0.5);      // 纹理坐标
vec3 position = vec3(1.0, 2.0, 3.0); // 3D位置
vec4 color = vec4(1.0, 0.0, 0.0, 1.0); // RGBA颜色

// 整数向量
ivec2 pixel = ivec2(100, 200);       // 像素坐标
ivec3 indices = ivec3(0, 1, 2);      // 索引
ivec4 data = ivec4(1, 2, 3, 4);      // 整数数据

// 无符号整数向量（GLSL 1.30+）
uvec2 size = uvec2(1024u, 768u);
uvec3 count = uvec3(10u, 20u, 30u);
uvec4 mask = uvec4(0xFFu);

// 布尔向量
bvec2 flags = bvec2(true, false);
bvec3 mask3 = bvec3(true);
bvec4 test = bvec4(false, true, true, false);

分量访问方式：

1. 坐标访问（xyz）

vec4 pos = vec4(1.0, 2.0, 3.0, 4.0);

float x = pos.x;  // 1.0
float y = pos.y;  // 2.0
float z = pos.z;  // 3.0
float w = pos.w;  // 4.0

vec3 xyz = pos.xyz;  // vec3(1.0, 2.0, 3.0)
vec2 xy = pos.xy;    // vec2(1.0, 2.0)

2. 颜色访问（rgba）

vec4 color = vec4(1.0, 0.5, 0.0, 1.0);

float red = color.r;      // 1.0
float green = color.g;    // 0.5
float blue = color.b;     // 0.0
float alpha = color.a;    // 1.0

vec3 rgb = color.rgb;     // vec3(1.0, 0.5, 0.0)

3. 纹理访问（stpq）

vec4 texCoord = vec4(0.0, 1.0, 0.5, 0.5);

float s = texCoord.s;  // 0.0
float t = texCoord.t;  // 1.0
float p = texCoord.p;  // 0.5
float q = texCoord.q;  // 0.5

vec2 st = texCoord.st;  // vec2(0.0, 1.0)

Swizzle操作：

1. 重新排序

vec4 color = vec4(1.0, 0.5, 0.0, 1.0);

vec4 bgra = color.bgra;  // vec4(0.0, 0.5, 1.0, 1.0)
vec3 bgr = color.bgr;    // vec3(0.0, 0.5, 1.0)
vec2 gr = color.gr;      // vec2(0.5, 1.0)

2. 分量重复

vec3 color = vec3(1.0, 0.5, 0.0);

vec3 rrr = color.rrr;  // vec3(1.0, 1.0, 1.0)
vec4 rrrr = color.rrrr; // vec4(1.0, 1.0, 1.0, 1.0)
vec2 rg = color.rg;    // vec2(1.0, 0.5)

3. 任意组合

vec4 v = vec4(1.0, 2.0, 3.0, 4.0);

vec4 wzyx = v.wzyx;     // vec4(4.0, 3.0, 2.0, 1.0)
vec3 xxy = v.xxy;       // vec3(1.0, 1.0, 2.0)
vec2 zw = v.zw;         // vec2(3.0, 4.0)

向量运算：

vec3 a = vec3(1.0, 2.0, 3.0);
vec3 b = vec3(4.0, 5.0, 6.0);

// 向量加法
vec3 sum = a + b;  // vec3(5.0, 7.0, 9.0)

// 向量减法
vec3 diff = b - a;  // vec3(3.0, 3.0, 3.0)

// 向量乘法（逐分量）
vec3 product = a * b;  // vec3(4.0, 10.0, 18.0)

// 标量乘法
vec3 scaled = a * 2.0;  // vec3(2.0, 4.0, 6.0)

// 点积
float dotProduct = dot(a, b);  // 32.0 (1*4 + 2*5 + 3*6)

// 叉积
vec3 crossProduct = cross(a, b);  // vec3(-3.0, 6.0, -3.0)

// 向量长度
float len = length(a);  // sqrt(14.0) ≈ 3.742

// 标准化
vec3 normalized = normalize(a);  // a / length(a)

实用技巧：

1. 颜色转换

// RGB转灰度
vec3 color = vec3(1.0, 0.5, 0.0);
float gray = dot(color, vec3(0.299, 0.587, 0.114));

// Alpha混合
vec4 color1 = vec4(1.0, 0.0, 0.0, 0.7);
vec4 color2 = vec4(0.0, 1.0, 0.0, 0.5);
vec3 blended = mix(color2.rgb, color1.rgb, color1.a);

2. 坐标变换

// 交换XY坐标
vec2 uv = vec2(0.3, 0.7);
vec2 swapped = uv.yx;  // vec2(0.7, 0.3)

// 镜像坐标
vec2 mirrored = vec2(1.0) - uv;  // vec2(0.7, 0.3)

3. 分量操作

vec4 data = vec4(1.0, 2.0, 3.0, 4.0);

// 只修改某些分量
data.xy = vec2(5.0, 6.0);  // vec4(5.0, 6.0, 3.0, 4.0)
data.w = 0.5;              // vec4(5.0, 6.0, 3.0, 0.5)

// 使用swizzle赋值
data.rgb = vec3(0.0);  // vec4(0.0, 0.0, 0.0, 0.5)

注意事项：

• 不能混用不同的访问方式（如color.xg是错误的）
• Swizzle最多支持4个分量
• 向量之间的运算要求维度相同或可广播

What are uniform, attribute, and varying variables? What are their differences?

考察点：变量限定符理解。

答案：

uniform、attribute和varying是GLSL中的变量限定符，用于控制数据在着色器间的传递和作用域。它们是连接JavaScript/应用层与GPU着色器的桥梁，理解它们的区别是着色器编程的基础。

三种变量对比：

1. uniform变量（全局常量）

// 顶点着色器
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform float time;

attribute vec3 position;

void main() {
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

// 片段着色器
uniform vec3 lightColor;
uniform vec3 objectColor;

void main() {
    gl_FragColor = vec4(objectColor * lightColor, 1.0);
}

JavaScript设置uniform：

// 获取uniform位置
const timeLocation = gl.getUniformLocation(program, 'time');
const colorLocation = gl.getUniformLocation(program, 'objectColor');

// 设置uniform值
gl.uniform1f(timeLocation, Date.now() / 1000);
gl.uniform3f(colorLocation, 1.0, 0.5, 0.0);

uniform特点：

• 在整个绘制调用中保持不变
• 所有顶点和片段共享相同值
• 适合传递变换矩阵、光照参数、时间等
• 数量有限制（通常几百个）

2. attribute变量（顶点属性）

// 顶点着色器
attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;
attribute vec3 color;

void main() {
    gl_Position = vec4(position, 1.0);
}

JavaScript设置attribute：

// 创建缓冲区
const positionBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
    -1.0, -1.0, 0.0,
     1.0, -1.0, 0.0,
     0.0,  1.0, 0.0
]), gl.STATIC_DRAW);

// 获取attribute位置
const positionLocation = gl.getAttribLocation(program, 'position');

// 启用attribute
gl.enableVertexAttribArray(positionLocation);

// 设置attribute指针
gl.vertexAttribPointer(
    positionLocation,
    3,           // 分量数量
    gl.FLOAT,    // 数据类型
    false,       // 是否归一化
    0,           // 步长
    0            // 偏移
);

attribute特点：

• 每个顶点可以有不同的值
• 只能在顶点着色器中使用
• 从顶点缓冲区读取数据
• 数量有限制（通常8-16个）

3. varying变量（顶点间插值）

// 顶点着色器
attribute vec3 position;
attribute vec2 uv;
attribute vec3 normal;

varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;

void main() {
    vUv = uv;
    vNormal = normal;
    vPosition = position;
    
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

// 片段着色器
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;

uniform sampler2D texture;

void main() {
    vec4 texColor = texture2D(texture, vUv);
    vec3 normal = normalize(vNormal);
    
    // 使用插值后的数据
    float lighting = max(dot(normal, vec3(0.0, 0.0, 1.0)), 0.0);
    gl_FragColor = vec4(texColor.rgb * lighting, 1.0);
}

varying插值机制：

// 三角形三个顶点的颜色
// 顶点1: vColor = vec3(1.0, 0.0, 0.0) // 红色
// 顶点2: vColor = vec3(0.0, 1.0, 0.0) // 绿色
// 顶点3: vColor = vec3(0.0, 0.0, 1.0) // 蓝色

// 片段着色器接收到的是插值后的颜色
// 三角形中心: vColor ≈ vec3(0.33, 0.33, 0.33) // 灰色

varying特点：

• 在顶点着色器中写入，片段着色器中读取
• 自动进行透视正确的插值
• 传递需要逐片段计算的数据
• 数量有限制（通常8-16个）

GLSL 3.00+（WebGL 2.0）语法：

// 用in/out替代attribute/varying

// 顶点着色器
#version 300 es
in vec3 position;      // 替代 attribute
in vec2 uv;

out vec2 vUv;          // 替代 varying（输出）
out vec3 vPosition;

void main() {
    vUv = uv;
    vPosition = position;
    gl_Position = vec4(position, 1.0);
}

// 片段着色器
#version 300 es
precision mediump float;

in vec2 vUv;           // 替代 varying（输入）
in vec3 vPosition;

out vec4 fragColor;    // 替代 gl_FragColor

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

实际应用场景：

// 顶点着色器 - 完整示例
attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vWorldPosition;

void main() {
    // 传递UV坐标
    vUv = uv;
    
    // 变换法向量
    vNormal = normalMatrix * normal;
    
    // 计算世界坐标
    vec4 worldPos = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPos.xyz;
    
    // 计算裁剪空间位置
    gl_Position = projectionMatrix * viewMatrix * worldPos;
}

// 片段着色器
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vWorldPosition;

uniform sampler2D diffuseMap;
uniform vec3 lightPosition;
uniform vec3 cameraPosition;

void main() {
    // 纹理采样
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // 光照计算
    vec3 normal = normalize(vNormal);
    vec3 lightDir = normalize(lightPosition - vWorldPosition);
    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
    
    // 漫反射
    float diff = max(dot(normal, lightDir), 0.0);
    
    // 镜面反射
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
    
    vec3 finalColor = texColor.rgb * (diff + spec);
    gl_FragColor = vec4(finalColor, texColor.a);
}

最佳实践：

• 命名约定：varying变量通常以v开头（如vUv, vNormal）
• 性能考虑：减少varying变量数量可提升性能
• 精度控制：移动端注意varying变量的精度设置
• 数据复用：相同的uniform可在顶点和片段着色器中共享

How to use matrix types in GLSL? What are the common matrix operations?

考察点：矩阵类型应用。

答案：

矩阵是GLSL中进行几何变换的核心工具，用于实现平移、旋转、缩放、投影等操作。GLSL采用列主序（column-major）存储矩阵，这与数学中的行主序不同，需要特别注意。

矩阵类型声明：

// 方阵
mat2 rotation2D = mat2(1.0);     // 2x2单位矩阵
mat3 rotation3D = mat3(1.0);     // 3x3单位矩阵
mat4 transform = mat4(1.0);      // 4x4单位矩阵

// 非方阵（GLSL 1.20+）
mat2x3 m23 = mat2x3(1.0);  // 2列3行
mat2x4 m24 = mat2x4(1.0);  // 2列4行
mat3x2 m32 = mat3x2(1.0);  // 3列2行
mat3x4 m34 = mat3x4(1.0);  // 3列4行
mat4x2 m42 = mat4x2(1.0);  // 4列2行
mat4x3 m43 = mat4x3(1.0);  // 4列3行

矩阵构造：

// 单位矩阵
mat4 identity = mat4(1.0);
// 等同于
mat4 identity = mat4(
    1.0, 0.0, 0.0, 0.0,  // 第一列
    0.0, 1.0, 0.0, 0.0,  // 第二列
    0.0, 0.0, 1.0, 0.0,  // 第三列
    0.0, 0.0, 0.0, 1.0   // 第四列
);

// 从列向量构造
vec4 col0 = vec4(1.0, 0.0, 0.0, 0.0);
vec4 col1 = vec4(0.0, 1.0, 0.0, 0.0);
vec4 col2 = vec4(0.0, 0.0, 1.0, 0.0);
vec4 col3 = vec4(0.0, 0.0, 0.0, 1.0);
mat4 m = mat4(col0, col1, col2, col3);

// 从mat3构造mat4
mat3 m3 = mat3(1.0);
mat4 m4 = mat4(m3);  // 右下角为1.0

矩阵访问：

mat4 m = mat4(
    1.0, 2.0, 3.0, 4.0,   // 第一列
    5.0, 6.0, 7.0, 8.0,   // 第二列
    9.0, 10.0, 11.0, 12.0, // 第三列
    13.0, 14.0, 15.0, 16.0 // 第四列
);

// 访问列
vec4 column0 = m[0];  // vec4(1.0, 2.0, 3.0, 4.0)
vec4 column1 = m[1];  // vec4(5.0, 6.0, 7.0, 8.0)

// 访问元素
float value = m[1][2];  // 第2列第3行 = 7.0

// 修改元素
m[0][1] = 99.0;  // 修改第1列第2行
m[2] = vec4(0.0);  // 修改整个第3列

常见矩阵运算：

1. 矩阵乘法

mat4 modelMatrix = mat4(1.0);
mat4 viewMatrix = mat4(1.0);
mat4 projectionMatrix = mat4(1.0);

// 矩阵相乘（注意顺序）
mat4 mvMatrix = viewMatrix * modelMatrix;
mat4 mvpMatrix = projectionMatrix * mvMatrix;

// 矩阵与向量相乘
vec4 position = vec4(1.0, 2.0, 3.0, 1.0);
vec4 transformed = mvpMatrix * position;

2. 坐标变换

attribute vec3 position;

uniform mat4 modelMatrix;       // 模型矩阵
uniform mat4 viewMatrix;        // 视图矩阵
uniform mat4 projectionMatrix;  // 投影矩阵

void main() {
    // 方式1：分步变换
    vec4 worldPos = modelMatrix * vec4(position, 1.0);
    vec4 viewPos = viewMatrix * worldPos;
    vec4 clipPos = projectionMatrix * viewPos;
    gl_Position = clipPos;
    
    // 方式2：合并矩阵
    mat4 mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

3. 法向量变换

attribute vec3 normal;
uniform mat4 modelMatrix;
uniform mat3 normalMatrix;  // 法向量矩阵（modelMatrix的逆转置）

varying vec3 vNormal;

void main() {
    // 正确的法向量变换
    vNormal = normalMatrix * normal;
    
    // 错误示例（不要这样做）
    // vNormal = mat3(modelMatrix) * normal;  // 非均匀缩放会出错
}

4. 矩阵内置函数

mat4 m = mat4(1.0);

// 转置
mat4 transposed = transpose(m);

// 求逆（如果存在）
mat4 inverted = inverse(m);

// 行列式（仅方阵）
float det = determinant(m);

// 矩阵相乘
mat4 result = matrixCompMult(m, m);  // 逐元素相乘

实用变换矩阵：

1. 2D旋转矩阵

mat2 rotate2D(float angle) {
    float c = cos(angle);
    float s = sin(angle);
    return mat2(
        c, s,   // 第一列
        -s, c   // 第二列
    );
}

// 使用
vec2 point = vec2(1.0, 0.0);
float angle = radians(45.0);
vec2 rotated = rotate2D(angle) * point;

2. 3D旋转矩阵（绕Z轴）

mat3 rotateZ(float angle) {
    float c = cos(angle);
    float s = sin(angle);
    return mat3(
        c, s, 0.0,   // 第一列
        -s, c, 0.0,  // 第二列
        0.0, 0.0, 1.0 // 第三列
    );
}

3. 缩放矩阵

mat4 scale(vec3 s) {
    return mat4(
        s.x, 0.0, 0.0, 0.0,
        0.0, s.y, 0.0, 0.0,
        0.0, 0.0, s.z, 0.0,
        0.0, 0.0, 0.0, 1.0
    );
}

4. 平移矩阵

mat4 translate(vec3 t) {
    return mat4(
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        t.x, t.y, t.z, 1.0  // 最后一列为平移
    );
}

完整应用示例：

// 顶点着色器
attribute vec3 position;
attribute vec3 normal;

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

varying vec3 vNormal;
varying vec3 vWorldPosition;

void main() {
    // 变换法向量
    vNormal = normalize(normalMatrix * normal);
    
    // 计算世界空间位置
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPosition.xyz;
    
    // MVP变换
    mat4 mvMatrix = viewMatrix * modelMatrix;
    mat4 mvpMatrix = projectionMatrix * mvMatrix;
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
varying vec3 vNormal;
varying vec3 vWorldPosition;

uniform vec3 lightPosition;
uniform vec3 cameraPosition;

void main() {
    vec3 normal = normalize(vNormal);
    vec3 lightDir = normalize(lightPosition - vWorldPosition);
    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
    
    // Phong光照
    float diff = max(dot(normal, lightDir), 0.0);
    
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
    
    vec3 color = vec3(diff + spec);
    gl_FragColor = vec4(color, 1.0);
}

性能优化技巧：

• 在JavaScript中预计算MVP矩阵，减少GPU计算
• 使用mat3处理法向量变换，比mat4更高效
• 避免在片段着色器中进行矩阵运算
• 合理使用uniform缓存矩阵数据

What is a Sampler in GLSL? What types are there?

考察点：纹理采样器。

答案：

采样器（Sampler）是GLSL中用于访问纹理数据的特殊类型，它封装了纹理对象和采样参数。采样器让着色器能够从纹理中读取颜色、法线、深度等数据，是实现复杂材质效果的基础。

常用采样器类型：

1. 2D纹理采样器

uniform sampler2D diffuseMap;      // 漫反射贴图
uniform sampler2D normalMap;       // 法线贴图
uniform sampler2D specularMap;     // 高光贴图
uniform sampler2D roughnessMap;    // 粗糙度贴图

varying vec2 vUv;

void main() {
    // 采样2D纹理
    vec4 diffuse = texture2D(diffuseMap, vUv);
    vec4 normal = texture2D(normalMap, vUv);
    
    gl_FragColor = diffuse;
}

2. 立方体贴图采样器

uniform samplerCube envMap;        // 环境贴图
uniform samplerCube skybox;        // 天空盒

varying vec3 vReflect;

void main() {
    // 采样立方体贴图（使用3D方向向量）
    vec4 envColor = textureCube(envMap, vReflect);
    
    gl_FragColor = envColor;
}

3. 3D纹理采样器（体积纹理）

uniform sampler3D volumeTexture;   // 体积纹理

varying vec3 vUvw;

void main() {
    // 采样3D纹理
    vec4 volumeColor = texture3D(volumeTexture, vUvw);
    
    gl_FragColor = volumeColor;
}

4. 阴影采样器

uniform sampler2DShadow shadowMap; // 阴影贴图

varying vec4 vShadowCoord;

void main() {
    // 深度比较采样
    float shadow = shadow2D(shadowMap, vShadowCoord.xyz).r;
    
    gl_FragColor = vec4(vec3(shadow), 1.0);
}

WebGL 2.0 / GLSL ES 3.00新增类型：

#version 300 es
precision mediump float;

// 整数纹理采样器
uniform isampler2D intTexture;     // 整数纹理
uniform usampler2D uintTexture;    // 无符号整数纹理

// 数组纹理
uniform sampler2DArray texArray;   // 2D纹理数组

// Multisample采样器
uniform sampler2DMS msTexture;     // 多重采样纹理

in vec2 vUv;
out vec4 fragColor;

void main() {
    // 使用texture函数（WebGL 2.0）
    vec4 color = texture(texArray, vec3(vUv, 0.0));
    fragColor = color;
}

纹理采样函数：

1. WebGL 1.0 / GLSL ES 1.00

// 2D纹理采样
vec4 color = texture2D(sampler2D, vec2 coord);
vec4 color = texture2D(sampler2D, vec2 coord, float bias);  // 带mipmap偏移

// 立方体贴图采样
vec4 color = textureCube(samplerCube, vec3 coord);

// 3D纹理采样（如果支持）
vec4 color = texture3D(sampler3D, vec3 coord);

// 投影纹理采样
vec4 color = texture2DProj(sampler2D, vec3 coord);  // coord.xy / coord.z
vec4 color = texture2DProj(sampler2D, vec4 coord);  // coord.xy / coord.w

2. WebGL 2.0 / GLSL ES 3.00

#version 300 es
precision mediump float;

uniform sampler2D tex;
in vec2 vUv;
out vec4 fragColor;

void main() {
    // 统一的texture函数
    vec4 color = texture(tex, vUv);
    
    // 带LOD的采样
    vec4 colorLod = textureLod(tex, vUv, 2.0);  // 指定mipmap层级
    
    // 纹理尺寸查询
    ivec2 size = textureSize(tex, 0);  // 获取level 0的尺寸
    
    // 偏移采样
    vec4 offset = textureOffset(tex, vUv, ivec2(1, 0));
    
    // 梯度采样
    vec4 grad = textureGrad(tex, vUv, vec2(1.0, 0.0), vec2(0.0, 1.0));
    
    fragColor = color;
}

纹理采样实用技巧：

1. 多重纹理混合

uniform sampler2D texture1;
uniform sampler2D texture2;
uniform float mixFactor;

varying vec2 vUv;

void main() {
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);
    
    // 线性混合
    vec4 finalColor = mix(color1, color2, mixFactor);
    
    gl_FragColor = finalColor;
}

2. 纹理坐标操作

uniform sampler2D texture;
uniform float time;

varying vec2 vUv;

void main() {
    // UV动画
    vec2 animatedUV = vUv + vec2(time * 0.1, 0.0);
    
    // UV缩放
    vec2 scaledUV = vUv * 2.0;
    
    // UV旋转
    float angle = time;
    mat2 rotation = mat2(cos(angle), sin(angle), -sin(angle), cos(angle));
    vec2 rotatedUV = rotation * (vUv - 0.5) + 0.5;
    
    // 采样
    vec4 color = texture2D(texture, animatedUV);
    
    gl_FragColor = color;
}

3. 法线贴图采样

uniform sampler2D normalMap;
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vTangent;
varying vec3 vBitangent;

void main() {
    // 采样法线贴图（存储在[0,1]范围）
    vec3 normalMapColor = texture2D(normalMap, vUv).rgb;
    
    // 转换到[-1,1]范围
    vec3 tangentNormal = normalize(normalMapColor * 2.0 - 1.0);
    
    // 构建TBN矩阵
    mat3 TBN = mat3(
        normalize(vTangent),
        normalize(vBitangent),
        normalize(vNormal)
    );
    
    // 变换到世界空间
    vec3 worldNormal = normalize(TBN * tangentNormal);
    
    gl_FragColor = vec4(worldNormal * 0.5 + 0.5, 1.0);
}

4. 环境映射

uniform samplerCube envMap;

varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 cameraPosition;

void main() {
    // 计算反射方向
    vec3 viewDir = normalize(vPosition - cameraPosition);
    vec3 reflectDir = reflect(viewDir, normalize(vNormal));
    
    // 采样环境贴图
    vec4 envColor = textureCube(envMap, reflectDir);
    
    gl_FragColor = envColor;
}

采样器配置（JavaScript）：

// 创建纹理
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);

// 上传纹理数据
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);

// 设置过滤模式
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);

// 设置包裹模式
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);

// 生成mipmap
gl.generateMipmap(gl.TEXTURE_2D);

// 绑定到采样器
const samplerLocation = gl.getUniformLocation(program, 'diffuseMap');
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.uniform1i(samplerLocation, 0);  // 使用纹理单元0

性能优化建议：

• 合理使用mipmap减少走样和提升性能
• 压缩纹理格式（如DXT、ETC2）减少带宽
• 使用纹理图集（texture atlas）减少纹理切换
• 避免在循环中进行dependent texture read

What is the role of vertex shaders? Where are they in the rendering pipeline?

考察点：顶点着色器概念。

答案：

顶点着色器是图形渲染管线中第一个可编程阶段，负责处理每个顶点的位置、颜色、纹理坐标等属性。它将顶点从模型空间变换到裁剪空间，并为后续的光栅化和片段着色器准备插值数据。

在渲染管线中的位置：

顶点数据输入
    ↓
[顶点着色器] ← 我们在这里
    ↓
图元装配
    ↓
光栅化
    ↓
片段着色器
    ↓
测试与混合
    ↓
帧缓冲输出

顶点着色器的主要职责：

1. 坐标变换（最核心）

attribute vec3 position;

uniform mat4 modelMatrix;       // 模型变换
uniform mat4 viewMatrix;        // 视图变换
uniform mat4 projectionMatrix;  // 投影变换

void main() {
    // 模型空间 → 世界空间
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    
    // 世界空间 → 视图空间（相机空间）
    vec4 viewPosition = viewMatrix * worldPosition;
    
    // 视图空间 → 裁剪空间
    gl_Position = projectionMatrix * viewPosition;
    
    // 或者合并为一个MVP矩阵
    // mat4 mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
    // gl_Position = mvpMatrix * vec4(position, 1.0);
}

2. 法向量变换

attribute vec3 normal;
uniform mat3 normalMatrix;  // 法向量矩阵（模型矩阵的逆转置）

varying vec3 vNormal;

void main() {
    // 变换法向量到世界空间
    vNormal = normalize(normalMatrix * normal);
    
    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.0);
}

3. 数据传递到片段着色器

attribute vec3 position;
attribute vec2 uv;
attribute vec3 normal;
attribute vec3 color;

varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vColor;
varying vec3 vPosition;

void main() {
    // 传递纹理坐标
    vUv = uv;
    
    // 传递法向量
    vNormal = normalMatrix * normal;
    
    // 传递顶点颜色
    vColor = color;
    
    // 传递世界坐标（用于光照计算）
    vec4 worldPos = modelMatrix * vec4(position, 1.0);
    vPosition = worldPos.xyz;
    
    gl_Position = projectionMatrix * viewMatrix * worldPos;
}

4. 顶点动画

attribute vec3 position;
attribute vec3 normal;

uniform float time;
uniform float amplitude;

varying vec3 vNormal;

void main() {
    vec3 pos = position;
    
    // 波浪动画
    float wave = sin(position.x * 2.0 + time) * amplitude;
    pos.y += wave;
    
    // 更新法向量（简化）
    vec3 tangent = vec3(1.0, cos(position.x * 2.0 + time) * amplitude * 2.0, 0.0);
    vNormal = normalize(cross(tangent, vec3(0.0, 0.0, 1.0)));
    
    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(pos, 1.0);
}

内置输入变量（attribute）：

// 标准顶点属性
attribute vec3 position;     // 顶点位置
attribute vec3 normal;       // 顶点法向量
attribute vec2 uv;           // 纹理坐标
attribute vec2 uv2;          // 第二套UV
attribute vec3 color;        // 顶点颜色
attribute vec3 tangent;      // 切线
attribute vec3 bitangent;    // 副切线

// 骨骼动画
attribute vec4 skinIndex;    // 骨骼索引
attribute vec4 skinWeight;   // 骨骼权重

内置输出变量：

// 必须输出的变量
gl_Position    // vec4类型，裁剪空间坐标

// 可选输出变量
gl_PointSize   // float类型，点的大小（渲染点时使用）

完整的顶点着色器示例：

// 顶点属性
attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

// 变换矩阵
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

// 传递到片段着色器
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vWorldPosition;
varying vec3 vViewPosition;

void main() {
    // 1. 计算世界坐标
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPosition.xyz;
    
    // 2. 计算视图坐标
    vec4 viewPosition = viewMatrix * worldPosition;
    vViewPosition = viewPosition.xyz;
    
    // 3. 计算裁剪空间坐标（输出）
    gl_Position = projectionMatrix * viewPosition;
    
    // 4. 变换法向量
    vNormal = normalize(normalMatrix * normal);
    
    // 5. 传递UV坐标
    vUv = uv;
}

高级应用场景：

1. 实例化渲染

attribute vec3 position;
attribute mat4 instanceMatrix;  // 每个实例的变换矩阵

uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

void main() {
    vec4 worldPosition = instanceMatrix * vec4(position, 1.0);
    gl_Position = projectionMatrix * viewMatrix * worldPosition;
}

2. 骨骼动画（蒙皮）

attribute vec3 position;
attribute vec4 skinIndex;
attribute vec4 skinWeight;

uniform mat4 boneMatrices[50];  // 骨骼矩阵数组

void main() {
    mat4 skinMatrix = 
        skinWeight.x * boneMatrices[int(skinIndex.x)] +
        skinWeight.y * boneMatrices[int(skinIndex.y)] +
        skinWeight.z * boneMatrices[int(skinIndex.z)] +
        skinWeight.w * boneMatrices[int(skinIndex.w)];
    
    vec4 skinnedPosition = skinMatrix * vec4(position, 1.0);
    
    gl_Position = projectionMatrix * viewMatrix * modelMatrix * skinnedPosition;
}

3. 变形目标（Morph Targets）

attribute vec3 position;
attribute vec3 morphTarget0;
attribute vec3 morphTarget1;

uniform float morphWeight0;
uniform float morphWeight1;

void main() {
    vec3 morphedPosition = position +
        morphTarget0 * morphWeight0 +
        morphTarget1 * morphWeight1;
    
    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(morphedPosition, 1.0);
}

顶点着色器性能考虑：

• 顶点数量：处理的顶点越多，性能消耗越大
• 变换复杂度：减少矩阵运算，预计算MVP矩阵
• 条件分支：避免在顶点着色器中使用if语句
• varying变量：减少传递到片段着色器的变量数量

实际应用：

• 几何变换：平移、旋转、缩放、投影
• 顶点动画：波浪、旗帜飘动、布料模拟
• 骨骼动画：角色动画、蒙皮
• LOD切换：根据距离调整顶点细节

What is gl_Position? How to use it?

考察点：内置输出变量。

答案：

gl_Position 是顶点着色器的内置输出变量，用于指定顶点在裁剪空间（Clip Space）中的最终位置。它是顶点着色器中唯一必须赋值的变量，GPU会根据这个位置进行后续的光栅化处理。

基本特征：

• 数据类型：vec4（齐次坐标）
• 坐标空间：裁剪空间（Clip Space）
• 必须赋值：每个顶点着色器都必须给gl_Position赋值
• 自动处理：GPU会自动进行透视除法转换到NDC空间

gl_Position的坐标含义：

gl_Position = vec4(x, y, z, w);
// x, y, z: 裁剪空间坐标
// w: 齐次坐标分量（用于透视除法）

// GPU自动执行透视除法得到NDC坐标：
// NDC.x = x / w  (范围 -1 到 1)
// NDC.y = y / w  (范围 -1 到 1)
// NDC.z = z / w  (范围 -1 到 1，深度值)

标准使用方式：

1. 完整MVP变换

attribute vec3 position;
uniform mat4 modelMatrix;       // 模型矩阵
uniform mat4 viewMatrix;        // 视图矩阵
uniform mat4 projectionMatrix;  // 投影矩阵

void main() {
    // 方式1：分步变换
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vec4 viewPosition = viewMatrix * worldPosition;
    gl_Position = projectionMatrix * viewPosition;
    
    // 方式2：组合矩阵（更高效）
    mat4 mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

2. 简化的2D渲染

attribute vec2 position;

void main() {
    // 直接输出2D坐标（已经在NDC空间）
    gl_Position = vec4(position, 0.0, 1.0);
    // position范围应该是-1到1
}

3. 正交投影

attribute vec3 position;
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;

void main() {
    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
    gl_Position = projectionMatrix * mvPosition;
    
    // 正交投影时，w分量通常为1.0
    // 透视除法不会改变坐标
}

高级应用场景：

1. 广告牌效果（Billboard）

attribute vec3 position;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform vec3 billboardPosition;

void main() {
    // 提取相机右向量和上向量
    vec3 cameraRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
    vec3 cameraUp = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
    
    // 构建面向相机的四边形
    vec3 worldPosition = billboardPosition 
        + cameraRight * position.x
        + cameraUp * position.y;
    
    gl_Position = projectionMatrix * viewMatrix * vec4(worldPosition, 1.0);
}

2. 自定义投影

attribute vec3 position;
uniform float customFov;
uniform float aspectRatio;

void main() {
    // 手动实现透视投影
    float f = 1.0 / tan(customFov / 2.0);
    float nearPlane = 0.1;
    float farPlane = 100.0;
    
    vec4 clipPos;
    clipPos.x = position.x * f / aspectRatio;
    clipPos.y = position.y * f;
    clipPos.z = (farPlane + nearPlane) / (nearPlane - farPlane) * position.z 
              + (2.0 * farPlane * nearPlane) / (nearPlane - farPlane);
    clipPos.w = -position.z;  // 透视除法的关键
    
    gl_Position = clipPos;
}

3. 屏幕空间效果

attribute vec3 position;

void main() {
    // 输出屏幕空间坐标（全屏四边形）
    gl_Position = vec4(position.xy, 0.0, 1.0);
    // 常用于后期处理效果
}

常见问题和注意事项：

1. 坐标空间理解

// 错误：直接使用模型空间坐标
gl_Position = vec4(position, 1.0);  // ❌ 坐标范围不对

// 正确：必须转换到裁剪空间
gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.0);  // ✅

2. 齐次坐标w分量

// 透视投影：w != 1
gl_Position = projectionMatrix * viewPosition;
// w通常等于-viewPosition.z（相机空间的z）

// 正交投影：w = 1
gl_Position = vec4(position.xy, 0.0, 1.0);

3. 深度值控制

// 强制物体渲染在最前面
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
gl_Position.z = 0.0;  // 修改深度为近平面

// 强制物体渲染在最后面
gl_Position.z = gl_Position.w;  // 深度为远平面

调试技巧：

// 方法1：输出到varying变量观察
varying vec4 vClipPosition;

void main() {
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    vClipPosition = gl_Position;  // 在片段着色器中可视化
}

// 方法2：简化测试
void main() {
    // 测试是否是坐标变换问题
    gl_Position = vec4(position * 0.5, 1.0);  // 直接输出模型坐标
}

性能考虑：

• 预计算MVP矩阵：在CPU端计算 mvpMatrix = P * V * M，减少GPU计算
• 避免重复计算：相同的矩阵变换只计算一次
• 精度问题：使用highp精度避免大坐标值的精度损失

实际应用：

• 3D渲染：标准的模型视图投影变换
• UI渲染：直接使用屏幕空间坐标
• 粒子系统：批量顶点的位置计算
• 地形渲染：高度场顶点变换

How to perform coordinate transformations in vertex shaders?

考察点：MVP变换。

答案：

顶点着色器中的坐标变换是3D图形渲染的核心，通过一系列矩阵变换将顶点从模型空间转换到裁剪空间。标准流程包括模型变换(M)、视图变换(V)和投影变换(P)，称为MVP变换。

坐标空间变换流程：

模型空间 → 世界空间 → 视图空间 → 裁剪空间 → NDC空间 → 屏幕空间
(Model)     (World)     (View)      (Clip)     (NDC)     (Screen)
   ↓           ↓           ↓           ↓          ↓
  M矩阵      V矩阵       P矩阵     透视除法   视口变换

完整的MVP变换实现：

attribute vec3 position;        // 模型空间坐标
attribute vec3 normal;          // 模型空间法向量
attribute vec2 uv;              // 纹理坐标

// 变换矩阵
uniform mat4 modelMatrix;       // M: 模型矩阵
uniform mat4 viewMatrix;        // V: 视图矩阵
uniform mat4 projectionMatrix;  // P: 投影矩阵
uniform mat3 normalMatrix;      // 法向量变换矩阵

// 输出到片段着色器
varying vec3 vWorldPosition;    // 世界空间位置
varying vec3 vViewPosition;     // 视图空间位置
varying vec3 vNormal;           // 世界空间法向量
varying vec2 vUv;

void main() {
    // 1. 模型空间 → 世界空间
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPosition.xyz;
    
    // 2. 世界空间 → 视图空间
    vec4 viewPosition = viewMatrix * worldPosition;
    vViewPosition = viewPosition.xyz;
    
    // 3. 视图空间 → 裁剪空间
    gl_Position = projectionMatrix * viewPosition;
    
    // 4. 法向量变换（只需旋转和缩放，不需要平移）
    vNormal = normalize(normalMatrix * normal);
    
    // 5. 纹理坐标直接传递
    vUv = uv;
}

各个变换矩阵详解：

1. 模型矩阵（Model Matrix）

// 模型矩阵 = 平移 × 旋转 × 缩放
uniform mat4 modelMatrix;

// 应用：将模型从局部坐标系变换到世界坐标系
vec4 worldPos = modelMatrix * vec4(position, 1.0);

// 手动构建模型矩阵示例（在CPU端更常见）
mat4 buildModelMatrix(vec3 translation, vec3 rotation, vec3 scale) {
    // 实际使用时在CPU端构建
    // 这里仅展示概念
    mat4 T = translationMatrix(translation);
    mat4 R = rotationMatrix(rotation);
    mat4 S = scaleMatrix(scale);
    return T * R * S;
}

2. 视图矩阵（View Matrix）

// 视图矩阵：相机的逆变换
uniform mat4 viewMatrix;

// 应用：从世界空间变换到相机空间
vec4 viewPos = viewMatrix * worldPos;

// 视图矩阵定义了相机的位置和朝向
// viewMatrix = inverse(cameraMatrix)

3. 投影矩阵（Projection Matrix）

// 透视投影矩阵
uniform mat4 projectionMatrix;

// 应用：从视图空间变换到裁剪空间
gl_Position = projectionMatrix * viewPos;

// 透视投影特点：
// - 近大远小效果
// - w分量 ≈ -viewPos.z
// - 需要透视除法

// 正交投影特点：
// - 无远近大小变化
// - w分量 = 1.0
// - 不需要实质性透视除法

优化方案：预组合矩阵

// 方案1：MVP矩阵在CPU端预计算
uniform mat4 mvpMatrix;  // projectionMatrix * viewMatrix * modelMatrix

void main() {
    gl_Position = mvpMatrix * vec4(position, 1.0);
    // 一次矩阵乘法，性能最优
}

// 方案2：MV矩阵预组合
uniform mat4 modelViewMatrix;  // viewMatrix * modelMatrix
uniform mat4 projectionMatrix;

void main() {
    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
    gl_Position = projectionMatrix * mvPosition;
    // 仍需要视图空间坐标时使用
}

法向量变换（重要）：

// 法向量变换需要特殊处理
uniform mat3 normalMatrix;  // transpose(inverse(modelViewMatrix的3x3部分))

void main() {
    // 正确的法向量变换
    vec3 transformedNormal = normalize(normalMatrix * normal);
    
    // 错误示例（非均匀缩放会导致法向量错误）
    // vec3 wrongNormal = mat3(modelMatrix) * normal;  // ❌
}

// 为什么需要逆转置矩阵？
// 1. 法向量是切空间的垂直向量
// 2. 非均匀缩放会改变垂直关系
// 3. 逆转置矩阵保持垂直性

实际应用示例：

1. 标准3D物体渲染

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

varying vec3 vNormal;
varying vec3 vPosition;
varying vec2 vUv;

void main() {
    // 完整MVP变换
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vec4 viewPosition = viewMatrix * worldPosition;
    gl_Position = projectionMatrix * viewPosition;
    
    // 传递数据到片段着色器
    vNormal = normalMatrix * normal;
    vPosition = viewPosition.xyz;
    vUv = uv;
}

2. 骨骼动画变换

attribute vec3 position;
attribute vec4 skinIndex;   // 骨骼索引
attribute vec4 skinWeight;  // 骨骼权重

uniform mat4 boneMatrices[50];
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

void main() {
    // 骨骼矩阵混合
    mat4 skinMatrix = 
        skinWeight.x * boneMatrices[int(skinIndex.x)] +
        skinWeight.y * boneMatrices[int(skinIndex.y)] +
        skinWeight.z * boneMatrices[int(skinIndex.z)] +
        skinWeight.w * boneMatrices[int(skinIndex.w)];
    
    // 应用骨骼变换
    vec4 skinnedPosition = skinMatrix * vec4(position, 1.0);
    
    // 继续标准变换
    vec4 viewPosition = viewMatrix * skinnedPosition;
    gl_Position = projectionMatrix * viewPosition;
}

3. 实例化渲染

attribute vec3 position;
attribute mat4 instanceMatrix;  // 每个实例的模型矩阵

uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

void main() {
    // 使用实例矩阵进行变换
    vec4 worldPosition = instanceMatrix * vec4(position, 1.0);
    vec4 viewPosition = viewMatrix * worldPosition;
    gl_Position = projectionMatrix * viewPosition;
}

特殊变换技巧：

1. 广告牌（面向相机）

uniform mat4 viewMatrix;
uniform vec3 objectPosition;

void main() {
    // 提取相机的方向向量
    vec3 cameraRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
    vec3 cameraUp = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
    
    // 构建始终面向相机的四边形
    vec3 worldPos = objectPosition 
        + cameraRight * position.x 
        + cameraUp * position.y;
    
    gl_Position = projectionMatrix * viewMatrix * vec4(worldPos, 1.0);
}

2. 天空盒变换

attribute vec3 position;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

void main() {
    // 移除视图矩阵的平移部分
    mat4 viewRotation = mat4(mat3(viewMatrix));
    
    vec4 pos = projectionMatrix * viewRotation * vec4(position, 1.0);
    
    // 强制深度为最大值
    gl_Position = pos.xyww;  // z = w，透视除法后 z = 1.0
}

性能优化建议：

• CPU端预计算：尽可能在CPU端组合矩阵
• 减少uniform数量：使用组合矩阵减少uniform传输
• 避免逆矩阵运算：在CPU端计算normalMatrix
• 批量处理：相同变换的对象批量渲染

常见错误：

// 错误1：矩阵乘法顺序错误
gl_Position = vec4(position, 1.0) * mvpMatrix;  // ❌ 错误顺序

// 正确
gl_Position = mvpMatrix * vec4(position, 1.0);  // ✅

// 错误2：法向量使用模型矩阵直接变换
vNormal = mat3(modelMatrix) * normal;  // ❌ 非均匀缩放时错误

// 正确
vNormal = normalMatrix * normal;  // ✅

// 错误3：忘记齐次坐标
gl_Position = projectionMatrix * vec3(position);  // ❌ 类型错误

// 正确
gl_Position = projectionMatrix * vec4(position, 1.0);  // ✅

实际应用：

• 3D游戏：角色、场景、道具的标准变换
• CAD软件：精确的几何变换和投影
• 数据可视化：3D图表的空间变换
• VR/AR：双眼立体投影变换

What are the commonly used built-in variables in vertex shaders?

考察点：内置变量使用。

答案：

GLSL顶点着色器提供了一系列内置变量，包括输入变量（attribute）、输出变量和特殊用途变量。这些内置变量简化了着色器编程，提供了与GPU固定管线的接口。

输出内置变量（必须或常用）：

1. gl_Position（必须）

// 类型：vec4
// 用途：输出顶点的裁剪空间坐标
void main() {
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

2. gl_PointSize（渲染点时使用）

// 类型：float
// 用途：指定点精灵的大小（像素）
void main() {
    gl_PointSize = 10.0;  // 点的半径为10像素
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 动态点大小（基于距离）
void main() {
    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
    float distance = length(mvPosition.xyz);
    gl_PointSize = 50.0 / distance;  // 距离越远点越小
    gl_Position = projectionMatrix * mvPosition;
}

输入内置变量（GLSL ES 1.0）：

1. gl_VertexID（GLSL 1.30+）

// 类型：int
// 用途：当前顶点的索引ID
// 常用于程序化生成几何体

void main() {
    // 基于顶点ID生成位置
    float angle = float(gl_VertexID) * 0.1;
    vec3 pos = vec3(cos(angle), sin(angle), 0.0);
    gl_Position = mvpMatrix * vec4(pos, 1.0);
}

2. gl_InstanceID（实例化渲染）

// 类型：int
// 用途：当前实例的索引
// 用于实例化渲染，每个实例有不同的ID

uniform vec3 instancePositions[100];

void main() {
    // 基于实例ID偏移位置
    vec3 offset = instancePositions[gl_InstanceID];
    vec3 worldPos = position + offset;
    gl_Position = mvpMatrix * vec4(worldPos, 1.0);
}

其他特殊内置变量：

1. gl_ClipDistance（裁剪平面距离）

// 类型：float[]
// 用途：用户自定义裁剪平面
// GLSL 1.30+

uniform vec4 clipPlane;  // 裁剪平面方程

void main() {
    vec4 worldPos = modelMatrix * vec4(position, 1.0);
    gl_Position = projectionMatrix * viewMatrix * worldPos;
    
    // 计算到裁剪平面的距离
    gl_ClipDistance[0] = dot(worldPos, clipPlane);
    // 如果距离 < 0，该顶点会被裁剪
}

实用示例集合：

1. 基础顶点着色器完整示例

// 输入属性（来自顶点缓冲）
attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;
attribute vec4 color;

// Uniform变量（来自程序）
uniform mat4 projectionMatrix;
uniform mat4 modelViewMatrix;
uniform mat3 normalMatrix;

// 输出到片段着色器
varying vec2 vUv;
varying vec3 vNormal;
varying vec4 vColor;

void main() {
    // 使用内置输出变量
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    gl_PointSize = 5.0;
    
    // 传递数据
    vUv = uv;
    vNormal = normalMatrix * normal;
    vColor = color;
}

2. 实例化渲染使用gl_InstanceID

attribute vec3 position;
attribute vec3 normal;

uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;

// 实例数据
uniform vec3 instanceOffsets[1000];
uniform vec3 instanceColors[1000];

varying vec3 vColor;

void main() {
    // 使用gl_InstanceID获取当前实例的数据
    vec3 offset = instanceOffsets[gl_InstanceID];
    vec3 instanceColor = instanceColors[gl_InstanceID];
    
    // 应用实例偏移
    vec3 worldPos = (modelMatrix * vec4(position, 1.0)).xyz + offset;
    gl_Position = projectionMatrix * viewMatrix * vec4(worldPos, 1.0);
    
    vColor = instanceColor;
}

3. 点精灵动画（使用gl_PointSize）

attribute vec3 position;
attribute float size;
attribute float alpha;

uniform mat4 mvpMatrix;
uniform float time;

varying float vAlpha;

void main() {
    // 动态点大小
    float pulse = sin(time * 2.0 + position.x) * 0.5 + 0.5;
    gl_PointSize = size * (1.0 + pulse * 0.5);
    
    gl_Position = mvpMatrix * vec4(position, 1.0);
    vAlpha = alpha;
}

4. 程序化几何生成（使用gl_VertexID）

uniform mat4 mvpMatrix;
uniform float radius;
uniform int segments;

varying vec3 vColor;

void main() {
    // 基于顶点ID生成圆形
    float angle = float(gl_VertexID) * 6.28318 / float(segments);
    vec3 pos = vec3(
        cos(angle) * radius,
        sin(angle) * radius,
        0.0
    );
    
    gl_Position = mvpMatrix * vec4(pos, 1.0);
    
    // 颜色也基于角度
    vColor = vec3(
        cos(angle) * 0.5 + 0.5,
        sin(angle) * 0.5 + 0.5,
        0.5
    );
}

WebGL/Three.js中的内置变量对应：

// Three.js自动提供的uniform
// - projectionMatrix
// - modelViewMatrix
// - viewMatrix
// - modelMatrix
// - normalMatrix
// - cameraPosition

// 在Three.js的顶点着色器中使用
const vertexShader = `
    // Three.js自动注入这些uniform
    uniform mat4 projectionMatrix;
    uniform mat4 modelViewMatrix;
    uniform mat3 normalMatrix;
    
    // 用户定义的attribute
    attribute vec3 position;
    attribute vec3 normal;
    
    varying vec3 vNormal;
    
    void main() {
        vNormal = normalMatrix * normal;
        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    }
`;

版本差异注意事项：

GLSL ES 1.0（WebGL 1.0）

// 使用attribute和varying
attribute vec3 position;
varying vec2 vUv;

void main() {
    gl_Position = vec4(position, 1.0);
}

GLSL ES 3.0（WebGL 2.0）

#version 300 es
// 使用in和out
in vec3 position;
out vec2 vUv;

void main() {
    gl_Position = vec4(position, 1.0);
}

实际应用：

• gl_Position：所有顶点着色器必须使用
• gl_PointSize：粒子系统、点云渲染
• gl_InstanceID：大量相同模型的高效渲染（树木、草地）
• gl_VertexID：程序化几何、GPU粒子
• gl_ClipDistance：水面反射裁剪、体积裁剪

How to pass data from vertex shader to fragment shader?

考察点：varying变量传递。

答案：

顶点着色器通过varying变量（GLSL ES 3.0中为out变量）将数据传递给片段着色器。GPU会自动对这些变量进行插值，使得每个片段都能获得平滑过渡的值。

基本传递机制：

// ========== 顶点着色器 ==========
attribute vec3 position;
attribute vec2 uv;
attribute vec3 normal;
attribute vec4 color;

uniform mat4 mvpMatrix;
uniform mat3 normalMatrix;

// varying变量声明（输出）
varying vec2 vUv;
varying vec3 vNormal;
varying vec4 vColor;
varying vec3 vPosition;

void main() {
    // 计算并输出到varying
    vUv = uv;
    vNormal = normalize(normalMatrix * normal);
    vColor = color;
    vPosition = position;
    
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// ========== 片段着色器 ==========
precision mediump float;

// varying变量声明（输入，必须与顶点着色器匹配）
varying vec2 vUv;
varying vec3 vNormal;
varying vec4 vColor;
varying vec3 vPosition;

void main() {
    // 使用插值后的varying变量
    vec3 normal = normalize(vNormal);
    gl_FragColor = vColor;
}

插值原理：

// 顶点着色器（三角形的三个顶点）
// 顶点1: vColor = vec4(1.0, 0.0, 0.0, 1.0)  红色
// 顶点2: vColor = vec4(0.0, 1.0, 0.0, 1.0)  绿色
// 顶点3: vColor = vec4(0.0, 0.0, 1.0, 1.0)  蓝色

// 片段着色器（三角形中心）
// 自动插值: vColor ≈ vec4(0.33, 0.33, 0.33, 1.0)  混合色

// 插值公式（重心坐标）：
// fragmentValue = w1 * vertex1Value + w2 * vertex2Value + w3 * vertex3Value
// 其中 w1 + w2 + w3 = 1.0

常见数据传递类型：

1. 纹理坐标传递

// 顶点着色器
attribute vec2 uv;
varying vec2 vUv;

void main() {
    vUv = uv;  // 直接传递
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
varying vec2 vUv;
uniform sampler2D diffuseMap;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    gl_FragColor = texColor;
}

2. 法向量传递

// 顶点着色器
attribute vec3 normal;
uniform mat3 normalMatrix;
varying vec3 vNormal;

void main() {
    // 变换后传递
    vNormal = normalize(normalMatrix * normal);
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
varying vec3 vNormal;

void main() {
    // 必须重新归一化（插值可能改变长度）
    vec3 N = normalize(vNormal);
    gl_FragColor = vec4(N * 0.5 + 0.5, 1.0);  // 可视化法向量
}

3. 世界坐标传递

// 顶点着色器
attribute vec3 position;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

varying vec3 vWorldPosition;

void main() {
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPosition.xyz;
    
    gl_Position = projectionMatrix * viewMatrix * worldPosition;
}

// 片段着色器
uniform vec3 lightPosition;
varying vec3 vWorldPosition;

void main() {
    // 使用世界坐标计算光照
    vec3 lightDir = normalize(lightPosition - vWorldPosition);
    // ... 光照计算
}

4. 顶点颜色传递

// 顶点着色器
attribute vec4 color;
varying vec4 vColor;

void main() {
    vColor = color;
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
varying vec4 vColor;

void main() {
    gl_FragColor = vColor;  // 自动插值的渐变色
}

高级传递技巧：

1. 多个坐标空间同时传递

// 顶点着色器
attribute vec3 position;
attribute vec3 normal;

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

// 传递多个空间的数据
varying vec3 vWorldPosition;
varying vec3 vViewPosition;
varying vec3 vWorldNormal;
varying vec3 vViewNormal;

void main() {
    // 世界空间
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vWorldPosition = worldPosition.xyz;
    vWorldNormal = normalize(mat3(modelMatrix) * normal);
    
    // 视图空间
    vec4 viewPosition = viewMatrix * worldPosition;
    vViewPosition = viewPosition.xyz;
    vViewNormal = normalize(normalMatrix * normal);
    
    gl_Position = projectionMatrix * viewPosition;
}

2. 自定义插值数据

// 顶点着色器
attribute vec3 position;
uniform float time;

varying float vDistance;
varying float vTime;

void main() {
    vDistance = length(position);  // 到原点的距离
    vTime = time;                  // uniform可以通过varying传递
    
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
varying float vDistance;
varying float vTime;

void main() {
    // 基于距离的脉冲效果
    float pulse = sin(vDistance * 5.0 - vTime * 3.0);
    vec3 color = vec3(pulse * 0.5 + 0.5);
    gl_FragColor = vec4(color, 1.0);
}

3. 平面映射（flat关键字）

// GLSL 1.30+
// 顶点着色器
#version 130
in vec3 position;
in vec3 color;

flat out vec3 vColor;  // 不插值，保持常量

void main() {
    vColor = color;
    gl_Position = mvpMatrix * vec4(position, 1.0);
}

// 片段着色器
#version 130
flat in vec3 vColor;  // 接收不插值的颜色

void main() {
    gl_FragColor = vec4(vColor, 1.0);  // 每个三角形颜色一致
}

性能优化建议：

1. 减少varying数量

// 不好的做法：传递过多varying
varying vec3 vPosition;
varying vec3 vNormal;
varying vec2 vUv;
varying vec4 vColor;
varying vec3 vTangent;
varying vec3 vBitangent;
varying float vAO;
// ... 更多

// 优化：只传递必要的数据
varying vec3 vNormal;
varying vec2 vUv;
// 其他数据在片段着色器中重新计算或从纹理读取

2. 合并向量通道

// 不好：使用多个float
varying float vMetalness;
varying float vRoughness;
varying float vAO;

// 优化：合并到vec3
varying vec3 vMaterialProps;  // xyz = metalness, roughness, ao

常见错误：

// 错误1：varying名称不匹配
// 顶点着色器
varying vec2 vUv;

// 片段着色器
varying vec2 uv;  // ❌ 名称必须完全一致

// 错误2：类型不匹配
// 顶点着色器
varying vec3 vColor;

// 片段着色器
varying vec4 vColor;  // ❌ 类型必须相同

// 错误3：忘记声明
// 顶点着色器
vNormal = normal;  // ❌ 未声明varying

// 正确
varying vec3 vNormal;
vNormal = normal;  // ✅

实际应用：

• 纹理映射：传递UV坐标进行纹理采样
• 光照计算：传递法向量和位置计算光照
• 顶点颜色：渐变效果、调试可视化
• 动画效果：传递时间、距离等动画参数

What is the role of fragment shaders? What data does it process?

考察点：片段着色器概念。

答案：

片段着色器（Fragment Shader）是图形渲染管线中的最后可编程阶段，负责计算每个像素（片段）的最终颜色。它在光栅化后运行，对屏幕上的每个像素执行一次，是实现各种视觉效果的核心。

核心作用：

1. 像素着色：计算每个像素的最终颜色值
2. 纹理采样：从纹理中读取颜色信息
3. 光照计算：实现各种光照模型
4. 特效实现：实现透明、反射、折射等效果

处理的数据类型：

1. 输入数据（从顶点着色器插值）

precision mediump float;

// 从顶点着色器接收的插值数据
varying vec2 vUv;              // 纹理坐标
varying vec3 vNormal;          // 法向量
varying vec3 vPosition;        // 位置
varying vec4 vColor;           // 顶点颜色

// Uniform数据（来自JavaScript）
uniform sampler2D diffuseMap;  // 纹理采样器
uniform vec3 lightPosition;    // 光源位置
uniform vec3 cameraPosition;   // 相机位置
uniform float time;            // 时间

void main() {
    // 处理插值数据...
}

2. 输出数据

void main() {
    // 必须输出颜色
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);  // RGBA
    
    // WebGL 2.0中的输出
    // out vec4 fragColor;
    // fragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

基础片段着色器示例：

1. 简单颜色输出

precision mediump float;

void main() {
    // 输出纯红色
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

2. 使用varying数据

precision mediump float;

varying vec2 vUv;
varying vec3 vNormal;

void main() {
    // UV坐标作为颜色（调试用）
    gl_FragColor = vec4(vUv, 0.0, 1.0);
    
    // 或者法向量可视化
    vec3 normalColor = vNormal * 0.5 + 0.5;  // 映射-1~1到0~1
    gl_FragColor = vec4(normalColor, 1.0);
}

3. 纹理采样

precision mediump float;

varying vec2 vUv;
uniform sampler2D diffuseMap;

void main() {
    // 从纹理采样颜色
    vec4 texColor = texture2D(diffuseMap, vUv);
    gl_FragColor = texColor;
}

常见处理任务：

1. 光照计算

precision mediump float;

varying vec3 vNormal;
varying vec3 vPosition;

uniform vec3 lightPosition;
uniform vec3 lightColor;
uniform vec3 objectColor;

void main() {
    // 标准化法向量
    vec3 normal = normalize(vNormal);
    
    // 光照方向
    vec3 lightDir = normalize(lightPosition - vPosition);
    
    // 漫反射
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = diff * lightColor;
    
    // 环境光
    vec3 ambient = vec3(0.1);
    
    // 最终颜色
    vec3 result = (ambient + diffuse) * objectColor;
    gl_FragColor = vec4(result, 1.0);
}

2. 多纹理混合

precision mediump float;

varying vec2 vUv;

uniform sampler2D texture1;
uniform sampler2D texture2;
uniform float mixFactor;

void main() {
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);
    
    // 线性混合两个纹理
    vec4 finalColor = mix(color1, color2, mixFactor);
    
    gl_FragColor = finalColor;
}

3. 透明度处理

precision mediump float;

varying vec2 vUv;
uniform sampler2D diffuseMap;
uniform float opacity;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // Alpha测试（完全透明或不透明）
    if (texColor.a < 0.5) {
        discard;  // 丢弃该片段
    }
    
    // Alpha混合
    gl_FragColor = vec4(texColor.rgb, texColor.a * opacity);
}

4. 程序化纹理生成

precision mediump float;

varying vec2 vUv;
uniform float time;

void main() {
    // 棋盘格图案
    float checker = mod(floor(vUv.x * 8.0) + floor(vUv.y * 8.0), 2.0);
    
    // 动画波纹
    float wave = sin(vUv.x * 10.0 + time) * sin(vUv.y * 10.0 + time);
    
    vec3 color = vec3(checker) * (0.5 + wave * 0.5);
    gl_FragColor = vec4(color, 1.0);
}

片段着色器执行流程：

光栅化 → 片段生成 → 片段着色器 → 深度测试 → Alpha混合 → 帧缓冲
         ↓           ↓              ↓          ↓          ↓
      生成片段    计算颜色        Z-buffer   透明混合   最终像素

性能特点：

1. 执行次数

// 片段着色器每个像素执行一次
// 1920x1080分辨率 = 2,073,600次执行/帧
// 60FPS = 124,416,000次执行/秒

// 因此片段着色器是性能瓶颈最可能出现的地方

2. 性能优化原则

// 不好：在片段着色器中进行复杂计算
void main() {
    // 每个像素都计算矩阵（非常慢）
    mat4 transform = complexMatrixCalculation();
    // ...
}

// 好：在顶点着色器或CPU端预计算
// 顶点着色器
varying vec3 vTransformedPos;
void main() {
    vTransformedPos = (transformMatrix * vec4(position, 1.0)).xyz;
}

// 片段着色器直接使用
varying vec3 vTransformedPos;
void main() {
    // 直接使用，无需重新计算
}

特殊功能：

1. discard语句

void main() {
    // 丢弃片段，不写入帧缓冲
    if (someCondition) {
        discard;
    }
    gl_FragColor = vec4(1.0);
}

2. 深度值操作

void main() {
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
    
    // 修改深度值（GLSL 1.30+）
    gl_FragDepth = customDepth;
}

实际应用：

• 材质渲染：金属、木材、玻璃等材质效果
• 后期处理：模糊、景深、色彩校正
• 特效：火焰、水面、雾效
• UI渲染：文字、图标、按钮

What is the difference between gl_FragColor and gl_FragData?

考察点：颜色输出变量。

答案：

gl_FragColor和gl_FragData都是片段着色器的输出变量，用于指定片段的最终颜色。两者的主要区别在于输出目标的数量：gl_FragColor用于单目标渲染，而gl_FragData用于多渲染目标（MRT）。

gl_FragColor（单目标输出）：

precision mediump float;

varying vec2 vUv;
uniform sampler2D diffuseMap;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // 输出到默认帧缓冲或当前绑定的渲染目标
    gl_FragColor = texColor;
    // 类型：vec4 (R, G, B, A)
}

gl_FragColor特点：

• 类型：vec4
• 用途：输出到单个渲染目标
• 支持：所有GLSL版本
• 最常用：标准的颜色输出方式

gl_FragData（多目标输出）：

precision mediump float;

varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;

uniform sampler2D diffuseMap;

void main() {
    // 延迟渲染G-Buffer输出
    
    // 输出0：漫反射颜色
    gl_FragData[0] = texture2D(diffuseMap, vUv);
    
    // 输出1：法向量
    gl_FragData[1] = vec4(vNormal * 0.5 + 0.5, 1.0);
    
    // 输出2：位置
    gl_FragData[2] = vec4(vPosition, 1.0);
    
    // 输出3：其他属性（金属度、粗糙度等）
    gl_FragData[3] = vec4(0.5, 0.8, 0.0, 1.0);
}

gl_FragData特点：

• 类型：vec4数组
• 用途：同时输出到多个渲染目标
• 索引：gl_FragData[n]，n = 0, 1, 2, …
• 限制：最大数量由GL_MAX_DRAW_BUFFERS决定（通常4-8个）

版本差异：

GLSL ES 1.0（WebGL 1.0）

// 单目标
void main() {
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

// 多目标（需要扩展支持）
#extension GL_EXT_draw_buffers : require
void main() {
    gl_FragData[0] = vec4(1.0, 0.0, 0.0, 1.0);
    gl_FragData[1] = vec4(0.0, 1.0, 0.0, 1.0);
}

GLSL ES 3.0（WebGL 2.0）

#version 300 es
precision mediump float;

// 显式声明输出变量
layout(location = 0) out vec4 outColor;
layout(location = 1) out vec4 outNormal;
layout(location = 2) out vec4 outPosition;

void main() {
    outColor = vec4(1.0, 0.0, 0.0, 1.0);
    outNormal = vec4(0.0, 1.0, 0.0, 1.0);
    outPosition = vec4(0.0, 0.0, 1.0, 1.0);
}

实际应用场景：

1. 延迟渲染（Deferred Rendering）

// G-Buffer Pass
precision mediump float;

varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;
varying vec3 vTangent;

uniform sampler2D albedoMap;
uniform sampler2D normalMap;
uniform sampler2D roughnessMap;

#extension GL_EXT_draw_buffers : require

void main() {
    // MRT输出多个缓冲
    vec4 albedo = texture2D(albedoMap, vUv);
    vec3 normal = texture2D(normalMap, vUv).rgb * 2.0 - 1.0;
    float roughness = texture2D(roughnessMap, vUv).r;
    
    // 输出到不同的渲染目标
    gl_FragData[0] = albedo;                          // 颜色缓冲
    gl_FragData[1] = vec4(normal, 1.0);              // 法向量缓冲
    gl_FragData[2] = vec4(vPosition, 1.0);           // 位置缓冲
    gl_FragData[3] = vec4(roughness, 0.0, 0.0, 1.0); // 材质属性缓冲
}

2. 后期处理多Pass

// 第一Pass：提取亮区
void main() {
    vec4 color = texture2D(sceneTexture, vUv);
    float brightness = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
    
    gl_FragData[0] = color;                           // 原始颜色
    gl_FragData[1] = brightness > 1.0 ? color : vec4(0.0); // 亮区
}

检查MRT支持：

// WebGL 1.0
const ext = gl.getExtension('WEBGL_draw_buffers');
if (ext) {
    const maxDrawBuffers = gl.getParameter(ext.MAX_DRAW_BUFFERS_WEBGL);
    console.log('支持的最大渲染目标数:', maxDrawBuffers);
}

// WebGL 2.0
const maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);
console.log('支持的最大渲染目标数:', maxDrawBuffers);

注意事项：

1. 不能同时使用

void main() {
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);  // ❌
    gl_FragData[0] = vec4(0.0, 1.0, 0.0, 1.0); // ❌
    // 只能选择一种方式
}

2. 性能影响

// MRT会增加带宽消耗
// 4个渲染目标 = 4倍的内存写入
// 移动设备上需要特别注意

3. 格式一致性

// 所有渲染目标必须有相同的尺寸和格式
const fb = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, fb);

// 附加多个颜色附件
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, ...);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, ...);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, ...);

实际应用：

• 延迟渲染：分离几何和光照计算
• 后期处理：多Pass效果（如SSR、SSAO）
• 粒子系统：输出多个属性供后续处理
• 体积渲染：分层数据输出

How to perform texture sampling in fragment shaders?

考察点：纹理采样基础。

答案：

纹理采样是片段着色器中最常见的操作之一，通过采样器（Sampler）从纹理中读取颜色值。GLSL提供了多种纹理采样函数，适用于不同类型的纹理和采样需求。

基础纹理采样：

precision mediump float;

// 纹理采样器（来自JavaScript）
uniform sampler2D diffuseMap;  // 2D纹理

// 纹理坐标（从顶点着色器插值）
varying vec2 vUv;

void main() {
    // 基础采样
    vec4 texColor = texture2D(diffuseMap, vUv);
    gl_FragColor = texColor;
}

主要采样函数：

1. texture2D（2D纹理）

uniform sampler2D diffuseMap;
varying vec2 vUv;

void main() {
    // 标准采样
    vec4 color = texture2D(diffuseMap, vUv);
    
    // 带LOD偏移的采样
    vec4 colorBias = texture2D(diffuseMap, vUv, bias);
    
    gl_FragColor = color;
}

2. textureCube（立方体纹理）

uniform samplerCube envMap;
varying vec3 vReflect;  // 反射方向

void main() {
    // 立方体贴图采样（使用3D方向向量）
    vec4 envColor = textureCube(envMap, vReflect);
    gl_FragColor = envColor;
}

3. texture2DProj（投影纹理）

uniform sampler2D shadowMap;
varying vec4 vShadowCoord;  // 齐次坐标

void main() {
    // 投影纹理采样（自动透视除法）
    vec4 shadowColor = texture2DProj(shadowMap, vShadowCoord);
    gl_FragColor = shadowColor;
}

纹理坐标处理：

1. UV坐标变换

uniform sampler2D diffuseMap;
uniform vec2 uvOffset;
uniform vec2 uvScale;
uniform float uvRotation;

varying vec2 vUv;

void main() {
    // 平移和缩放
    vec2 uv = vUv * uvScale + uvOffset;
    
    // 旋转
    float s = sin(uvRotation);
    float c = cos(uvRotation);
    mat2 rotationMatrix = mat2(c, -s, s, c);
    uv = rotationMatrix * (uv - 0.5) + 0.5;
    
    vec4 texColor = texture2D(diffuseMap, uv);
    gl_FragColor = texColor;
}

2. UV重复和镜像

uniform sampler2D diffuseMap;
varying vec2 vUv;

void main() {
    // 方式1：使用fract实现重复
    vec2 uv = fract(vUv * 3.0);  // 重复3次
    
    // 方式2：镜像重复
    vec2 mirrorUv = abs(fract(vUv * 0.5) * 2.0 - 1.0);
    
    vec4 texColor = texture2D(diffuseMap, uv);
    gl_FragColor = texColor;
}

多纹理混合：

1. 简单混合

uniform sampler2D texture1;
uniform sampler2D texture2;
uniform float mixFactor;

varying vec2 vUv;

void main() {
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);
    
    // 线性混合
    vec4 finalColor = mix(color1, color2, mixFactor);
    
    gl_FragColor = finalColor;
}

2. 使用混合贴图

uniform sampler2D baseTexture;
uniform sampler2D detailTexture;
uniform sampler2D blendMap;

varying vec2 vUv;

void main() {
    vec4 base = texture2D(baseTexture, vUv);
    vec4 detail = texture2D(detailTexture, vUv * 4.0);  // 细节纹理重复
    float blend = texture2D(blendMap, vUv).r;
    
    vec4 finalColor = mix(base, detail, blend);
    gl_FragColor = finalColor;
}

3. 三向投影纹理映射

uniform sampler2D textureX;
uniform sampler2D textureY;
uniform sampler2D textureZ;

varying vec3 vPosition;
varying vec3 vNormal;

void main() {
    vec3 absNormal = abs(vNormal);
    
    // 根据法向量确定权重
    vec3 weights = absNormal / (absNormal.x + absNormal.y + absNormal.z);
    
    // 三个方向采样
    vec4 colorX = texture2D(textureX, vPosition.yz) * weights.x;
    vec4 colorY = texture2D(textureY, vPosition.xz) * weights.y;
    vec4 colorZ = texture2D(textureZ, vPosition.xy) * weights.z;
    
    gl_FragColor = colorX + colorY + colorZ;
}

高级采样技术：

1. 手动Mipmap采样

#extension GL_EXT_shader_texture_lod : enable

uniform sampler2D diffuseMap;
varying vec2 vUv;
uniform float mipmapLevel;

void main() {
    // 显式指定mipmap级别
    vec4 color = texture2DLodEXT(diffuseMap, vUv, mipmapLevel);
    gl_FragColor = color;
}

2. 导数和纹理过滤

uniform sampler2D diffuseMap;
varying vec2 vUv;

void main() {
    // 计算UV坐标的偏导数
    vec2 dx = dFdx(vUv);
    vec2 dy = dFdy(vUv);
    
    // 基于导数的渐变过滤
    vec4 color = texture2DGradEXT(diffuseMap, vUv, dx, dy);
    
    gl_FragColor = color;
}

3. 纹理数组采样（WebGL 2.0）

#version 300 es
precision mediump float;
precision mediump sampler2DArray;

uniform sampler2DArray textureArray;
in vec2 vUv;
in float vTextureIndex;

out vec4 fragColor;

void main() {
    // 从纹理数组采样
    vec4 color = texture(textureArray, vec3(vUv, vTextureIndex));
    fragColor = color;
}

纹理过滤和采样：

// GPU会根据纹理参数自动选择过滤方式

// 放大过滤（Magnification）：
// - NEAREST：最近邻（锯齿状）
// - LINEAR：双线性插值（平滑）

// 缩小过滤（Minification）：
// - NEAREST：最近邻
// - LINEAR：双线性插值  
// - NEAREST_MIPMAP_NEAREST：mipmap最近邻
// - LINEAR_MIPMAP_NEAREST：mipmap双线性
// - NEAREST_MIPMAP_LINEAR：mipmap三线性
// - LINEAR_MIPMAP_LINEAR：完全三线性过滤

性能优化：

// 1. 减少纹理采样次数
// 不好
void main() {
    vec4 c1 = texture2D(tex, vUv);
    vec4 c2 = texture2D(tex, vUv);  // 重复采样
    gl_FragColor = (c1 + c2) * 0.5;
}

// 好
void main() {
    vec4 c = texture2D(tex, vUv);
    gl_FragColor = c;  // 只采样一次
}

// 2. 使用合适的纹理格式和大小
// - 2的幂次方尺寸（256, 512, 1024）更高效
// - 压缩纹理格式（DXT, ETC, ASTC）减少带宽

// 3. Mipmap使用
// - 启用mipmap可以提高缩小时的性能和质量
// - 减少纹理缓存未命中

实际应用：

• 材质贴图：漫反射、法线、粗糙度贴图
• 光照贴图：预烘焙光照
• 环境映射：反射和折射
• UI纹理：图标、文字、界面元素

How to implement simple color blending in fragment shaders?

考察点：颜色计算基础。

答案：

颜色混合是片段着色器中的基础操作，用于组合多个颜色值创建最终输出。GLSL提供了内置函数和数学运算来实现各种混合效果。

基础混合方法：

1. 线性插值（mix函数）

precision mediump float;

uniform vec3 color1;
uniform vec3 color2;
uniform float mixFactor;  // 0.0到1.0

void main() {
    // 线性混合：result = color1 * (1-t) + color2 * t
    vec3 blendedColor = mix(color1, color2, mixFactor);
    
    gl_FragColor = vec4(blendedColor, 1.0);
}

2. 加法混合

varying vec4 vColor1;
varying vec4 vColor2;

void main() {
    // 简单相加
    vec3 result = vColor1.rgb + vColor2.rgb;
    
    // 限制在0-1范围
    result = clamp(result, 0.0, 1.0);
    // 或者使用min
    result = min(result, vec3(1.0));
    
    gl_FragColor = vec4(result, 1.0);
}

3. 乘法混合

uniform sampler2D diffuseMap;
uniform vec3 tintColor;
varying vec2 vUv;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // 乘法混合（调色）
    vec3 result = texColor.rgb * tintColor;
    
    gl_FragColor = vec4(result, texColor.a);
}

纹理与颜色混合：

1. 纹理调色

uniform sampler2D diffuseMap;
uniform vec3 tintColor;
uniform float tintStrength;

varying vec2 vUv;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // 线性混合纹理颜色和调色
    vec3 tinted = mix(texColor.rgb, texColor.rgb * tintColor, tintStrength);
    
    gl_FragColor = vec4(tinted, texColor.a);
}

2. 顶点颜色与纹理混合

uniform sampler2D diffuseMap;
varying vec2 vUv;
varying vec4 vColor;

void main() {
    vec4 texColor = texture2D(diffuseMap, vUv);
    
    // 纹理颜色 × 顶点颜色
    vec4 finalColor = texColor * vColor;
    
    gl_FragColor = finalColor;
}

常见混合模式：

1. 正常混合（Alpha混合）

vec4 source = texture2D(sourceTexture, vUv);
vec4 destination = texture2D(destTexture, vUv);

// Alpha混合公式
vec3 result = source.rgb * source.a + destination.rgb * (1.0 - source.a);
float alpha = source.a + destination.a * (1.0 - source.a);

gl_FragColor = vec4(result, alpha);

2. 叠加混合（Overlay）

vec3 overlay(vec3 base, vec3 blend) {
    return mix(
        2.0 * base * blend,
        1.0 - 2.0 * (1.0 - base) * (1.0 - blend),
        step(0.5, base)
    );
}

void main() {
    vec3 baseColor = texture2D(baseTexture, vUv).rgb;
    vec3 blendColor = texture2D(blendTexture, vUv).rgb;
    
    vec3 result = overlay(baseColor, blendColor);
    gl_FragColor = vec4(result, 1.0);
}

3. 屏幕混合（Screen）

vec3 screen(vec3 base, vec3 blend) {
    return 1.0 - (1.0 - base) * (1.0 - blend);
}

void main() {
    vec3 base = texture2D(texture1, vUv).rgb;
    vec3 blend = texture2D(texture2, vUv).rgb;
    
    vec3 result = screen(base, blend);
    gl_FragColor = vec4(result, 1.0);
}

4. 正片叠底（Multiply）

void main() {
    vec3 base = texture2D(texture1, vUv).rgb;
    vec3 blend = texture2D(texture2, vUv).rgb;
    
    vec3 result = base * blend;
    gl_FragColor = vec4(result, 1.0);
}

渐变效果：

1. 线性渐变

uniform vec3 color1;
uniform vec3 color2;
varying vec2 vUv;

void main() {
    // 水平渐变
    vec3 gradient = mix(color1, color2, vUv.x);
    
    // 垂直渐变
    // vec3 gradient = mix(color1, color2, vUv.y);
    
    // 对角渐变
    // float t = (vUv.x + vUv.y) * 0.5;
    // vec3 gradient = mix(color1, color2, t);
    
    gl_FragColor = vec4(gradient, 1.0);
}

2. 径向渐变

uniform vec3 centerColor;
uniform vec3 edgeColor;
uniform vec2 center;

varying vec2 vUv;

void main() {
    float dist = distance(vUv, center);
    
    // 径向渐变
    vec3 gradient = mix(centerColor, edgeColor, dist);
    
    gl_FragColor = vec4(gradient, 1.0);
}

3. 平滑过渡

uniform vec3 color1;
uniform vec3 color2;
varying vec2 vUv;

void main() {
    // 使用smoothstep创建平滑过渡
    float t = smoothstep(0.3, 0.7, vUv.x);
    vec3 gradient = mix(color1, color2, t);
    
    gl_FragColor = vec4(gradient, 1.0);
}

多颜色混合：

1. 三色混合

uniform vec3 color1;
uniform vec3 color2;
uniform vec3 color3;
varying vec2 vUv;

void main() {
    float t = vUv.x;
    
    vec3 result;
    if (t < 0.5) {
        result = mix(color1, color2, t * 2.0);
    } else {
        result = mix(color2, color3, (t - 0.5) * 2.0);
    }
    
    gl_FragColor = vec4(result, 1.0);
}

2. 基于遮罩的混合

uniform sampler2D texture1;
uniform sampler2D texture2;
uniform sampler2D maskTexture;

varying vec2 vUv;

void main() {
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);
    float mask = texture2D(maskTexture, vUv).r;
    
    // 使用遮罩混合两个纹理
    vec4 result = mix(color1, color2, mask);
    
    gl_FragColor = result;
}

实用混合函数库：

// 加法混合
vec3 add(vec3 base, vec3 blend) {
    return min(base + blend, vec3(1.0));
}

// 减法混合
vec3 subtract(vec3 base, vec3 blend) {
    return max(base - blend, vec3(0.0));
}

// 变暗混合
vec3 darken(vec3 base, vec3 blend) {
    return min(base, blend);
}

// 变亮混合
vec3 lighten(vec3 base, vec3 blend) {
    return max(base, blend);
}

// 柔光混合
vec3 softLight(vec3 base, vec3 blend) {
    return mix(
        2.0 * base * blend + base * base * (1.0 - 2.0 * blend),
        sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend),
        step(0.5, blend)
    );
}

void main() {
    vec3 base = texture2D(texture1, vUv).rgb;
    vec3 blend = texture2D(texture2, vUv).rgb;
    
    // 选择需要的混合模式
    vec3 result = softLight(base, blend);
    
    gl_FragColor = vec4(result, 1.0);
}

实际应用：

• 材质混合：泥土、雪、草地等地形纹理混合
• 光照合成：环境光、直接光、间接光混合
• 后期特效：滤镜、色彩校正、晕影效果
• UI渲染：图标着色、按钮状态混合

What are the commonly used mathematical functions in GLSL? What are their application scenarios?

考察点：数学函数应用。

答案：

GLSL提供了丰富的内置数学函数，涵盖三角函数、指数函数、通用数学函数等。这些函数在GPU上高度优化，是实现各种着色器效果的基础工具。合理使用数学函数能够实现复杂的视觉效果和物理模拟。

常用数学函数分类：

1. 三角函数

float angle = 1.57;  // 90度（弧度制）

// 基础三角函数
float s = sin(angle);      // 正弦值
float c = cos(angle);      // 余弦值
float t = tan(angle);      // 正切值

// 反三角函数
float asinVal = asin(0.5);  // 反正弦
float acosVal = acos(0.5);  // 反余弦
float atanVal = atan(1.0);  // 反正切
float atan2Val = atan(y, x); // 两参数反正切

// 弧度角度转换
float radians = radians(180.0);  // 度转弧度：π
float degrees = degrees(3.14159); // 弧度转度：180

应用场景：

• 圆周运动、波浪效果
• 角度计算和旋转变换
• 周期性动画和振荡效果

2. 指数和对数函数

float x = 2.0;

// 指数函数
float powVal = pow(x, 3.0);     // x的3次方：8.0
float expVal = exp(x);          // e的x次方
float exp2Val = exp2(x);        // 2的x次方：4.0

// 对数函数
float logVal = log(x);          // 自然对数
float log2Val = log2(x);        // 以2为底的对数：1.0

// 平方根
float sqrtVal = sqrt(x);        // 平方根：1.414
float invSqrtVal = inversesqrt(x); // 平方根倒数（快速）

应用场景：

• 光照衰减计算
• HDR色调映射
• 距离场计算优化

3. 通用数学函数

float value = -3.5;

// 绝对值和符号
float absVal = abs(value);      // 绝对值：3.5
float signVal = sign(value);    // 符号：-1.0

// 取整函数
float floorVal = floor(value);  // 向下取整：-4.0
float ceilVal = ceil(value);    // 向上取整：-3.0
float fractVal = fract(value);  // 小数部分：0.5
float roundVal = round(value);  // 四舍五入（GLSL 1.30+）

// 取值范围控制
float minVal = min(value, 0.0);     // 最小值：-3.5
float maxVal = max(value, 0.0);     // 最大值：0.0
float clampVal = clamp(value, -2.0, 2.0); // 限制范围：-2.0

// 取模
float modVal = mod(value, 2.0); // 取模运算

应用场景：

• 纹理坐标重复（fract）
• 数值范围限制（clamp）
• 周期性图案生成（mod）

4. 插值和混合函数

float a = 0.0;
float b = 1.0;
float t = 0.5;

// 线性插值
float mixVal = mix(a, b, t);    // 线性混合：0.5

// 阶跃函数
float stepVal = step(0.5, t);   // t >= 0.5 ? 1.0 : 0.0

// 平滑插值
float smoothVal = smoothstep(0.0, 1.0, t);  // 平滑过渡：0.5

应用场景：

• 颜色混合和渐变
• 边缘检测和软化
• 动画过渡和缓动

实用代码示例：

1. 波浪效果

// 顶点着色器中的波浪变形
uniform float time;
attribute vec3 position;

void main() {
    vec3 pos = position;
    
    // 使用sin函数创建波浪
    float wave = sin(pos.x * 2.0 + time) * 0.5;
    wave += sin(pos.z * 1.5 + time * 0.7) * 0.3;
    pos.y += wave;
    
    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
}

2. 光照衰减

// 片段着色器中的距离衰减
uniform vec3 lightPosition;
varying vec3 vWorldPosition;

void main() {
    float distance = length(lightPosition - vWorldPosition);
    
    // 使用平方衰减（物理正确）
    float attenuation = 1.0 / (1.0 + distance * distance);
    
    // 或使用更平滑的衰减
    float smoothAttenuation = 1.0 / pow(distance + 1.0, 2.0);
    
    vec3 finalColor = lightColor * attenuation;
    gl_FragColor = vec4(finalColor, 1.0);
}

3. 程序化纹理

// 使用数学函数生成棋盘格图案
varying vec2 vUv;

void main() {
    // 使用floor和mod创建棋盘格
    float checker = mod(floor(vUv.x * 8.0) + floor(vUv.y * 8.0), 2.0);
    
    vec3 color = vec3(checker);
    gl_FragColor = vec4(color, 1.0);
}

4. 脉冲动画

uniform float time;
varying vec2 vUv;

void main() {
    // 组合多个三角函数创建复杂动画
    float pulse = sin(time * 3.0) * 0.5 + 0.5;
    float ring = sin((length(vUv - 0.5) - time * 0.1) * 20.0) * 0.5 + 0.5;
    
    vec3 color = vec3(pulse * ring);
    gl_FragColor = vec4(color, 1.0);
}

性能优化建议：

• 使用内置函数：GPU对内置函数高度优化，比自己实现快得多
• 避免pow函数：对于平方操作，x * x 比 pow(x, 2.0) 更快
• 使用inversesqrt：计算归一化时，inversesqrt 比 1.0 / sqrt() 更快
• 预计算常量：在CPU端预计算三角函数等常量值

函数组合技巧：

// 创建周期性边界框
float box(vec2 p, vec2 size) {
    vec2 d = abs(p) - size;
    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
}

// 平滑最小值（用于形状混合）
float smin(float a, float b, float k) {
    float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
    return mix(b, a, h) - k * h * (1.0 - h);
}

// 重映射函数
float remap(float value, float inMin, float inMax, float outMin, float outMax) {
    return outMin + (outMax - outMin) * (value - inMin) / (inMax - inMin);
}

实际应用：

• 动画效果：使用sin/cos实现周期性运动
• 光照计算：使用pow实现高光指数、使用exp实现衰减
• 程序化生成：使用floor/fract生成重复图案
• 图像处理：使用clamp限制颜色范围、使用mix混合颜色

What are the vector and matrix operation functions in GLSL?

考察点：向量矩阵函数。

答案：

GLSL提供了专门的向量和矩阵运算函数，这些函数针对GPU的并行架构优化，能够高效处理图形计算中常见的线性代数运算。掌握这些函数是编写高性能着色器的关键。

向量运算函数：

1. 向量长度和距离

vec3 v = vec3(3.0, 4.0, 0.0);
vec3 a = vec3(1.0, 2.0, 3.0);
vec3 b = vec3(4.0, 6.0, 8.0);

// 向量长度（模）
float len = length(v);  // sqrt(3²+4²+0²) = 5.0

// 两点距离
float dist = distance(a, b);  // length(b - a)

// 点乘（标量积）
float dotProduct = dot(a, b);  // a.x*b.x + a.y*b.y + a.z*b.z

// 叉乘（向量积）- 仅适用于vec3
vec3 crossProduct = cross(a, b);  // 垂直于a和b的向量

2. 向量归一化和反射

vec3 v = vec3(3.0, 4.0, 0.0);
vec3 normal = vec3(0.0, 1.0, 0.0);

// 归一化（单位向量）
vec3 normalized = normalize(v);  // v / length(v)

// 面法线归一化（快速）
vec3 faceforward = faceforward(normal, v, normal);  // 确保法向量朝向正确

// 反射向量
vec3 incident = normalize(vec3(1.0, -1.0, 0.0));
vec3 reflected = reflect(incident, normal);  // 光线反射

// 折射向量
float eta = 0.67;  // 折射率比（如空气到水）
vec3 refracted = refract(incident, normal, eta);  // 光线折射

矩阵运算函数：

1. 矩阵乘法

mat4 modelMatrix = mat4(1.0);
mat4 viewMatrix = mat4(1.0);
mat4 projectionMatrix = mat4(1.0);

// 矩阵 × 矩阵
mat4 mvMatrix = viewMatrix * modelMatrix;
mat4 mvpMatrix = projectionMatrix * mvMatrix;

// 矩阵 × 向量
vec4 position = vec4(1.0, 2.0, 3.0, 1.0);
vec4 transformed = mvpMatrix * position;

// 向量 × 矩阵（注意：不同于矩阵×向量）
vec4 result = position * mvpMatrix;  // 转置后的效果

2. 矩阵转置和逆

mat3 m = mat3(1.0);

// 转置矩阵（GLSL 1.20+）
mat3 transposed = transpose(m);

// 逆矩阵（GLSL 1.40+）
mat3 inverted = inverse(m);

// 行列式（GLSL 1.50+）
float det = determinant(m);

实用向量函数示例：

1. 光照计算基础

precision mediump float;

varying vec3 vNormal;
varying vec3 vPosition;

uniform vec3 lightPosition;
uniform vec3 cameraPosition;

void main() {
    // 归一化法向量
    vec3 N = normalize(vNormal);
    
    // 光照方向
    vec3 L = normalize(lightPosition - vPosition);
    
    // 视线方向
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 漫反射强度
    float diffuse = max(dot(N, L), 0.0);
    
    // 反射向量
    vec3 R = reflect(-L, N);
    
    // 镜面反射强度
    float specular = pow(max(dot(R, V), 0.0), 32.0);
    
    vec3 color = vec3(diffuse + specular);
    gl_FragColor = vec4(color, 1.0);
}

2. 环境映射（反射和折射）

precision mediump float;

varying vec3 vNormal;
varying vec3 vPosition;

uniform vec3 cameraPosition;
uniform samplerCube envMap;
uniform float refractionRatio;

void main() {
    vec3 N = normalize(vNormal);
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 反射
    vec3 reflectDir = reflect(-V, N);
    vec4 reflectColor = textureCube(envMap, reflectDir);
    
    // 折射
    vec3 refractDir = refract(-V, N, refractionRatio);
    vec4 refractColor = textureCube(envMap, refractDir);
    
    // 菲涅尔效应
    float fresnel = pow(1.0 - dot(V, N), 3.0);
    
    // 混合反射和折射
    vec4 finalColor = mix(refractColor, reflectColor, fresnel);
    gl_FragColor = finalColor;
}

3. 向量投影和正交化

// 向量投影
vec3 projectVector(vec3 a, vec3 b) {
    return dot(a, b) / dot(b, b) * b;
}

// 格拉姆-施密特正交化
void orthogonalize(inout vec3 tangent, vec3 normal) {
    tangent = normalize(tangent - dot(tangent, normal) * normal);
}

// 构建切线空间矩阵
mat3 buildTBN(vec3 normal, vec3 tangent) {
    vec3 N = normalize(normal);
    vec3 T = normalize(tangent);
    T = normalize(T - dot(T, N) * N);  // 格拉姆-施密特正交化
    vec3 B = cross(N, T);  // 副切线
    
    return mat3(T, B, N);
}

矩阵变换示例：

1. 手动构建变换矩阵

// 平移矩阵
mat4 translate(vec3 v) {
    return mat4(
        1.0, 0.0, 0.0, 0.0,
        0.0, 1.0, 0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        v.x, v.y, v.z, 1.0
    );
}

// 缩放矩阵
mat4 scale(vec3 v) {
    return mat4(
        v.x, 0.0, 0.0, 0.0,
        0.0, v.y, 0.0, 0.0,
        0.0, 0.0, v.z, 0.0,
        0.0, 0.0, 0.0, 1.0
    );
}

// 绕Z轴旋转矩阵
mat4 rotateZ(float angle) {
    float c = cos(angle);
    float s = sin(angle);
    return mat4(
        c,  s,  0.0, 0.0,
        -s, c,  0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0
    );
}

2. 矩阵分解和提取

// 从变换矩阵提取缩放
vec3 extractScale(mat4 m) {
    return vec3(
        length(vec3(m[0][0], m[0][1], m[0][2])),
        length(vec3(m[1][0], m[1][1], m[1][2])),
        length(vec3(m[2][0], m[2][1], m[2][2]))
    );
}

// 从变换矩阵提取旋转
mat3 extractRotation(mat4 m) {
    vec3 scale = extractScale(m);
    return mat3(
        m[0].xyz / scale.x,
        m[1].xyz / scale.y,
        m[2].xyz / scale.z
    );
}

// 从变换矩阵提取平移
vec3 extractTranslation(mat4 m) {
    return m[3].xyz;
}

性能优化技巧：

// 优化1：避免重复计算
// 不好
void main() {
    vec3 lightDir = normalize(lightPos - vPos);
    float diffuse = max(dot(normalize(vNormal), lightDir), 0.0);
    float specular = pow(max(dot(reflect(-lightDir, normalize(vNormal)), viewDir), 0.0), 32.0);
    // normalize(vNormal)被调用了两次
}

// 好
void main() {
    vec3 N = normalize(vNormal);  // 只计算一次
    vec3 L = normalize(lightPos - vPos);
    float diffuse = max(dot(N, L), 0.0);
    float specular = pow(max(dot(reflect(-L, N), viewDir), 0.0), 32.0);
}

// 优化2：使用内置函数而非手动实现
// 不好：手动计算归一化
vec3 normalize_manual(vec3 v) {
    float len = sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
    return v / len;
}

// 好：使用内置函数
vec3 normalized = normalize(v);  // GPU优化的实现

向量swizzle组合：

vec4 color = vec4(1.0, 0.5, 0.25, 1.0);

// swizzle读取
vec3 rgb = color.rgb;
vec2 rg = color.rg;
float r = color.r;

// swizzle重排
vec4 bgra = color.bgra;
vec3 grb = color.grb;

// swizzle写入
color.rgb = vec3(0.0);
color.xy = vec2(1.0);

// 重复分量
vec3 rrr = color.rrr;
vec4 xxxx = color.xxxx;

实际应用：

• 光照计算：dot、reflect、normalize用于实现各种光照模型
• 空间变换：矩阵运算实现模型、视图、投影变换
• 法线贴图：cross、normalize构建切线空间矩阵
• 物理模拟：向量运算实现碰撞检测、力场计算

What are the texture lookup functions in GLSL? What are their differences?

考察点：纹理函数对比。

答案：

GLSL提供了多种纹理查找（采样）函数，支持不同类型的纹理和采样方式。这些函数在不同版本的GLSL中有所不同，理解它们的区别对于正确编写着色器至关重要。

GLSL ES 1.0 / WebGL 1.0 纹理函数：

1. 基础纹理采样

precision mediump float;

uniform sampler2D diffuseMap;      // 2D纹理采样器
uniform samplerCube envMap;        // 立方体纹理采样器

varying vec2 vUv;
varying vec3 vReflect;

void main() {
    // 2D纹理采样
    vec4 color = texture2D(diffuseMap, vUv);
    
    // 立方体纹理采样
    vec4 envColor = textureCube(envMap, vReflect);
    
    gl_FragColor = color;
}

2. 带LOD（Level of Detail）的采样

// 顶点着色器中使用（自动计算mipmap级别）
vec4 color = texture2DLod(diffuseMap, vUv, 0.0);

// 片段着色器中指定mipmap级别
vec4 color = texture2DLodEXT(diffuseMap, vUv, 2.0);  // 需要扩展

// 立方体纹理LOD
vec4 envColor = textureCubeLodEXT(envMap, vReflect, 1.0);

3. 投影纹理采样

// 透视投影纹理（自动除以w分量）
vec4 projCoord = vec4(vUv.x, vUv.y, 0.0, 2.0);
vec4 color = texture2DProj(diffuseMap, projCoord);
// 等价于: texture2D(diffuseMap, projCoord.xy / projCoord.w)

// 4D投影坐标
vec4 shadowCoord = vec4(vUv, depth, 1.0);
vec4 shadowColor = texture2DProj(shadowMap, shadowCoord);

GLSL ES 3.0 / WebGL 2.0 纹理函数：

1. 统一的texture函数

#version 300 es
precision mediump float;

uniform sampler2D diffuseMap;
uniform samplerCube envMap;
uniform sampler2DArray textureArray;
uniform sampler3D volumeTexture;

in vec2 vUv;
in vec3 vReflect;

out vec4 fragColor;

void main() {
    // 统一使用texture函数（自动根据采样器类型选择）
    vec4 color2D = texture(diffuseMap, vUv);
    vec4 colorCube = texture(envMap, vReflect);
    vec4 colorArray = texture(textureArray, vec3(vUv, 0.0));
    vec4 color3D = texture(volumeTexture, vec3(vUv, 0.5));
    
    fragColor = color2D;
}

2. 纹理尺寸查询

// 获取纹理尺寸
ivec2 texSize = textureSize(diffuseMap, 0);  // 0是mipmap级别

// 计算像素坐标
vec2 pixelCoord = vUv * vec2(texSize);

3. 纹理偏移采样

// 偏移采样（用于边缘检测、模糊等）
vec4 color = textureOffset(diffuseMap, vUv, ivec2(1, 0));

// 多次偏移采样实现模糊
vec4 blur = vec4(0.0);
blur += textureOffset(diffuseMap, vUv, ivec2(-1, -1));
blur += textureOffset(diffuseMap, vUv, ivec2( 0, -1));
blur += textureOffset(diffuseMap, vUv, ivec2( 1, -1));
blur += textureOffset(diffuseMap, vUv, ivec2(-1,  0));
blur += textureOffset(diffuseMap, vUv, ivec2( 0,  0));
blur += textureOffset(diffuseMap, vUv, ivec2( 1,  0));
blur += textureOffset(diffuseMap, vUv, ivec2(-1,  1));
blur += textureOffset(diffuseMap, vUv, ivec2( 0,  1));
blur += textureOffset(diffuseMap, vUv, ivec2( 1,  1));
blur /= 9.0;

4. 手动梯度采样

// 使用显式梯度进行采样（用于自定义mipmap选择）
vec2 dUvdx = dFdx(vUv);
vec2 dUvdy = dFdy(vUv);
vec4 color = textureGrad(diffuseMap, vUv, dUvdx, dUvdy);

5. 纹理采集（Texel Fetch）

// 直接读取指定像素（不使用滤波）
ivec2 coord = ivec2(100, 200);
vec4 texel = texelFetch(diffuseMap, coord, 0);  // 0是mipmap级别

纹理函数对比表：

实用代码示例：

1. 多纹理混合（WebGL 1.0）

precision mediump float;

uniform sampler2D texture1;
uniform sampler2D texture2;
uniform sampler2D blendMask;
uniform float mixFactor;

varying vec2 vUv;

void main() {
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);
    vec4 mask = texture2D(blendMask, vUv);
    
    // 使用遮罩混合
    vec4 finalColor = mix(color1, color2, mask.r * mixFactor);
    
    gl_FragColor = finalColor;
}

2. 法线贴图采样

precision mediump float;

uniform sampler2D normalMap;
varying vec2 vUv;
varying vec3 vTangent;
varying vec3 vBitangent;
varying vec3 vNormal;

void main() {
    // 采样法线贴图
    vec3 normalTex = texture2D(normalMap, vUv).xyz;
    
    // 从[0, 1]转换到[-1, 1]
    normalTex = normalTex * 2.0 - 1.0;
    
    // 构建TBN矩阵（切线空间到世界空间）
    mat3 TBN = mat3(vTangent, vBitangent, vNormal);
    
    // 转换法向量到世界空间
    vec3 normal = normalize(TBN * normalTex);
    
    gl_FragColor = vec4(normal * 0.5 + 0.5, 1.0);
}

3. 环境映射（立方体贴图）

precision mediump float;

uniform samplerCube envMap;
uniform vec3 cameraPosition;

varying vec3 vPosition;
varying vec3 vNormal;

void main() {
    vec3 N = normalize(vNormal);
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 计算反射向量
    vec3 R = reflect(-V, N);
    
    // 采样立方体贴图
    vec4 envColor = textureCube(envMap, R);
    
    gl_FragColor = envColor;
}

4. 纹理数组采样（WebGL 2.0）

#version 300 es
precision mediump float;

uniform sampler2DArray textureArray;
uniform int layerIndex;

in vec2 vUv;
out vec4 fragColor;

void main() {
    // 采样纹理数组的指定层
    vec3 coord = vec3(vUv, float(layerIndex));
    vec4 color = texture(textureArray, coord);
    
    fragColor = color;
}

5. 自定义Mipmap级别（WebGL 2.0）

#version 300 es
precision mediump float;

uniform sampler2D diffuseMap;
uniform float lodLevel;

in vec2 vUv;
out vec4 fragColor;

void main() {
    // 手动指定mipmap级别
    vec4 color = textureLod(diffuseMap, vUv, lodLevel);
    
    fragColor = color;
}

6. 边缘检测（Sobel算子）

#version 300 es
precision mediump float;

uniform sampler2D inputTexture;
in vec2 vUv;
out vec4 fragColor;

void main() {
    // Sobel算子
    float sobelX = 0.0;
    float sobelY = 0.0;
    
    // X方向卷积核
    sobelX += textureOffset(inputTexture, vUv, ivec2(-1, -1)).r * -1.0;
    sobelX += textureOffset(inputTexture, vUv, ivec2(-1,  0)).r * -2.0;
    sobelX += textureOffset(inputTexture, vUv, ivec2(-1,  1)).r * -1.0;
    sobelX += textureOffset(inputTexture, vUv, ivec2( 1, -1)).r *  1.0;
    sobelX += textureOffset(inputTexture, vUv, ivec2( 1,  0)).r *  2.0;
    sobelX += textureOffset(inputTexture, vUv, ivec2( 1,  1)).r *  1.0;
    
    // Y方向卷积核
    sobelY += textureOffset(inputTexture, vUv, ivec2(-1, -1)).r * -1.0;
    sobelY += textureOffset(inputTexture, vUv, ivec2( 0, -1)).r * -2.0;
    sobelY += textureOffset(inputTexture, vUv, ivec2( 1, -1)).r * -1.0;
    sobelY += textureOffset(inputTexture, vUv, ivec2(-1,  1)).r *  1.0;
    sobelY += textureOffset(inputTexture, vUv, ivec2( 0,  1)).r *  2.0;
    sobelY += textureOffset(inputTexture, vUv, ivec2( 1,  1)).r *  1.0;
    
    float edge = sqrt(sobelX * sobelX + sobelY * sobelY);
    fragColor = vec4(vec3(edge), 1.0);
}

性能优化建议：

• 减少纹理采样次数：每次采样都有性能开销
• 使用合适的LOD：在顶点着色器中使用texture2DLod避免隐式导数计算
• 缓存采样结果：避免重复采样相同坐标
• 使用合适的纹理格式：选择最小的可用格式
• 启用Mipmapping：提高远处物体的采样性能

常见应用：

• diffuseMap：漫反射颜色纹理
• normalMap：法线贴图（切线空间）
• specularMap：高光强度纹理
• envMap：环境映射（反射、折射）
• shadowMap：阴影深度纹理
• lightMap：烘焙光照纹理

How to use GLSL geometric functions (length, distance, dot, cross, etc.)?

考察点：几何计算函数。

答案：

GLSL的几何函数是图形编程中最基础和常用的工具，用于处理向量和空间计算。这些函数在光照计算、碰撞检测、距离场等场景中必不可少。

核心几何函数：

1. length - 向量长度

// 计算向量的模（长度）
vec3 v = vec3(3.0, 4.0, 0.0);
float len = length(v);  // sqrt(3² + 4² + 0²) = 5.0

// 实际应用：计算距离衰减
varying vec3 vPosition;
uniform vec3 lightPosition;

void main() {
    float dist = length(lightPosition - vPosition);
    float attenuation = 1.0 / (1.0 + dist * dist);
    
    gl_FragColor = vec4(vec3(attenuation), 1.0);
}

2. distance - 两点距离

// 计算两点之间的欧几里得距离
vec3 point1 = vec3(0.0, 0.0, 0.0);
vec3 point2 = vec3(3.0, 4.0, 0.0);
float dist = distance(point1, point2);  // 5.0
// 等价于: length(point2 - point1)

// 实际应用：距离场绘制
varying vec2 vUv;
uniform vec2 center;

void main() {
    float d = distance(vUv, center);
    float circle = step(d, 0.5);  // 半径0.5的圆
    
    gl_FragColor = vec4(vec3(circle), 1.0);
}

3. dot - 点乘（标量积）

// 计算两个向量的点乘
vec3 a = vec3(1.0, 0.0, 0.0);
vec3 b = vec3(0.0, 1.0, 0.0);
float dotProduct = dot(a, b);  // 0.0 (垂直)

// 点乘的几何意义：
// dot(a, b) = |a| * |b| * cos(θ)
// - 结果 > 0：夹角 < 90°（同向）
// - 结果 = 0：夹角 = 90°（垂直）
// - 结果 < 0：夹角 > 90°（反向）

// 实际应用：Lambert漫反射
precision mediump float;
varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 lightPosition;

void main() {
    vec3 N = normalize(vNormal);
    vec3 L = normalize(lightPosition - vPosition);
    
    // Lambert模型：光照强度与法向量和光线方向夹角的余弦成正比
    float diffuse = max(dot(N, L), 0.0);
    
    gl_FragColor = vec4(vec3(diffuse), 1.0);
}

4. cross - 叉乘（向量积）

// 计算两个vec3向量的叉乘（仅支持vec3）
vec3 a = vec3(1.0, 0.0, 0.0);
vec3 b = vec3(0.0, 1.0, 0.0);
vec3 c = cross(a, b);  // vec3(0.0, 0.0, 1.0)

// 叉乘的特性：
// 1. 结果向量垂直于a和b
// 2. |c| = |a| * |b| * sin(θ)
// 3. 遵循右手定则

// 实际应用：构建TBN矩阵（切线空间）
attribute vec3 position;
attribute vec3 normal;
attribute vec3 tangent;

varying mat3 vTBN;

void main() {
    vec3 N = normalize(normalMatrix * normal);
    vec3 T = normalize(normalMatrix * tangent);
    
    // 计算副切线（Bitangent）
    vec3 B = cross(N, T);
    
    // 构建TBN矩阵
    vTBN = mat3(T, B, N);
    
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

5. normalize - 归一化

// 将向量转换为单位向量（长度为1）
vec3 v = vec3(3.0, 4.0, 0.0);
vec3 normalized = normalize(v);  // vec3(0.6, 0.8, 0.0)
// 等价于: v / length(v)

// 注意：对零向量normalize会产生未定义行为
vec3 zero = vec3(0.0);
vec3 bad = normalize(zero);  // 未定义！

// 安全的归一化
vec3 safeNormalize(vec3 v) {
    float len = length(v);
    return len > 0.0 ? v / len : vec3(0.0, 0.0, 1.0);
}

6. faceforward - 面向正确方向的法向量

// 确保法向量朝向观察者
vec3 N = vec3(0.0, 0.0, 1.0);     // 原始法向量
vec3 I = vec3(0.0, 0.0, -1.0);    // 入射向量
vec3 Nref = vec3(0.0, 0.0, 1.0);  // 参考法向量

// 如果dot(Nref, I) < 0，返回N，否则返回-N
vec3 facing = faceforward(N, I, Nref);

// 实际应用：双面材质
varying vec3 vNormal;
varying vec3 vViewDirection;

void main() {
    // 确保法向量总是朝向摄像机
    vec3 normal = faceforward(vNormal, vViewDirection, vNormal);
    
    gl_FragColor = vec4(normal * 0.5 + 0.5, 1.0);
}

7. reflect - 反射向量

// 计算反射向量
vec3 I = normalize(vec3(1.0, -1.0, 0.0));  // 入射向量
vec3 N = vec3(0.0, 1.0, 0.0);              // 法向量
vec3 R = reflect(I, N);  // 反射向量
// 公式: R = I - 2.0 * dot(N, I) * N

// 实际应用：镜面反射（Phong高光）
precision mediump float;
varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 lightPosition;
uniform vec3 cameraPosition;

void main() {
    vec3 N = normalize(vNormal);
    vec3 L = normalize(lightPosition - vPosition);
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 计算反射光线
    vec3 R = reflect(-L, N);
    
    // Phong高光
    float specular = pow(max(dot(R, V), 0.0), 32.0);
    
    gl_FragColor = vec4(vec3(specular), 1.0);
}

8. refract - 折射向量

// 计算折射向量（Snell定律）
vec3 I = normalize(vec3(0.0, -1.0, 0.0));  // 入射向量
vec3 N = vec3(0.0, 1.0, 0.0);              // 法向量
float eta = 0.67;  // 折射率比（n1/n2，如空气到水: 1.0/1.33）
vec3 T = refract(I, N, eta);  // 折射向量

// 全内反射情况：当入射角度大于临界角时，返回零向量
// 临界角 = asin(n2/n1)

// 实际应用：玻璃/水材质
precision mediump float;
uniform samplerCube envMap;
varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 cameraPosition;

void main() {
    vec3 N = normalize(vNormal);
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 折射（空气到玻璃：1.0/1.52）
    vec3 refractVec = refract(-V, N, 1.0 / 1.52);
    vec4 refractColor = textureCube(envMap, refractVec);
    
    // 反射
    vec3 reflectVec = reflect(-V, N);
    vec4 reflectColor = textureCube(envMap, reflectVec);
    
    // 菲涅尔效应
    float fresnel = pow(1.0 - max(dot(V, N), 0.0), 3.0);
    
    gl_FragColor = mix(refractColor, reflectColor, fresnel);
}

实用几何函数组合：

1. 软阴影/光晕效果

varying vec2 vUv;
uniform vec2 lightPos;
uniform float radius;

void main() {
    float dist = distance(vUv, lightPos);
    
    // 方式1：硬边缘
    float hardGlow = step(dist, radius);
    
    // 方式2：线性衰减
    float linearGlow = 1.0 - clamp(dist / radius, 0.0, 1.0);
    
    // 方式3：平滑衰减
    float smoothGlow = 1.0 - smoothstep(0.0, radius, dist);
    
    // 方式4：二次衰减
    float quadraticGlow = 1.0 / (1.0 + dist * dist);
    
    gl_FragColor = vec4(vec3(smoothGlow), 1.0);
}

2. 边缘检测（Rim Lighting）

precision mediump float;
varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 cameraPosition;
uniform vec3 rimColor;
uniform float rimPower;

void main() {
    vec3 N = normalize(vNormal);
    vec3 V = normalize(cameraPosition - vPosition);
    
    // 使用点乘检测边缘
    float rim = 1.0 - max(dot(N, V), 0.0);
    rim = pow(rim, rimPower);  // 控制边缘宽度
    
    vec3 color = rimColor * rim;
    gl_FragColor = vec4(color, 1.0);
}

3. 平面投影

// 将点投影到平面上
vec3 projectPointOnPlane(vec3 point, vec3 planeNormal, vec3 planePoint) {
    vec3 v = point - planePoint;
    float dist = dot(v, planeNormal);
    return point - dist * planeNormal;
}

// 点到平面的距离
float distanceToPlane(vec3 point, vec3 planeNormal, vec3 planePoint) {
    return abs(dot(point - planePoint, planeNormal));
}

4. 半球光照

precision mediump float;
varying vec3 vNormal;
uniform vec3 skyColor;
uniform vec3 groundColor;

void main() {
    vec3 N = normalize(vNormal);
    vec3 up = vec3(0.0, 1.0, 0.0);
    
    // 使用点乘在天空和地面颜色之间插值
    float hemisphere = dot(N, up) * 0.5 + 0.5;
    vec3 color = mix(groundColor, skyColor, hemisphere);
    
    gl_FragColor = vec4(color, 1.0);
}

5. 距离场应用（SDF）

// 球体距离场
float sdSphere(vec3 p, float radius) {
    return length(p) - radius;
}

// 盒子距离场
float sdBox(vec3 p, vec3 b) {
    vec3 d = abs(p) - b;
    return length(max(d, 0.0)) + min(max(d.x, max(d.y, d.z)), 0.0);
}

// 圆环距离场
float sdTorus(vec3 p, vec2 t) {
    vec2 q = vec2(length(p.xz) - t.x, p.y);
    return length(q) - t.y;
}

// 应用：软阴影
float softShadow(vec3 ro, vec3 rd, float mint, float maxt, float k) {
    float res = 1.0;
    for(float t = mint; t < maxt; ) {
        float h = sdSphere(ro + rd * t, 1.0);
        if(h < 0.001) return 0.0;
        res = min(res, k * h / t);
        t += h;
    }
    return res;
}

性能优化建议：

// 优化1：避免重复计算length
// 不好
float dist1 = length(v);
float dist2 = length(v);

// 好
float dist = length(v);

// 优化2：比较距离时可以使用平方距离（避免sqrt）
// 不好
if(length(v) < threshold) { }

// 好
float sqrThreshold = threshold * threshold;
if(dot(v, v) < sqrThreshold) { }  // dot(v,v) = length(v)²

// 优化3：归一化向量后避免重复归一化
// 不好
vec3 L = normalize(lightDir);
float diffuse = dot(N, normalize(lightDir));

// 好
vec3 L = normalize(lightDir);
float diffuse = dot(N, L);

实际应用场景：

• 光照计算：dot用于计算漫反射和镜面反射
• 环境映射：reflect和refract用于实现反射和折射效果
• 距离场渲染：length和distance用于SDF
• 法线贴图：cross用于构建切线空间矩阵
• 碰撞检测：distance用于判断物体间距离
• 边缘光：dot用于检测视角和法线的夹角

How to use interpolation functions (mix, smoothstep, step, etc.) in GLSL?

考察点：插值函数应用。

答案：

插值函数是GLSL中非常强大的工具，用于在两个值之间进行平滑或阶跃过渡。它们在颜色混合、动画缓动、边缘软化、阈值判断等场景中应用广泛。

核心插值函数：

1. mix - 线性插值

// 基础语法：mix(a, b, t)
// 返回: a * (1 - t) + b * t

// 标量插值
float a = 0.0;
float b = 1.0;
float t = 0.5;
float result = mix(a, b, t);  // 0.5

// 向量插值
vec3 color1 = vec3(1.0, 0.0, 0.0);  // 红色
vec3 color2 = vec3(0.0, 0.0, 1.0);  // 蓝色
vec3 blended = mix(color1, color2, 0.5);  // 紫色

// 实际应用：颜色渐变
varying vec2 vUv;
uniform vec3 startColor;
uniform vec3 endColor;

void main() {
    vec3 color = mix(startColor, endColor, vUv.x);
    gl_FragColor = vec4(color, 1.0);
}

2. step - 阶跃函数

// 基础语法：step(edge, x)
// 返回: x < edge ? 0.0 : 1.0

float edge = 0.5;
float value = 0.7;
float result = step(edge, value);  // 1.0

// 实际应用：阈值判断
varying vec2 vUv;

void main() {
    // 创建一个圆形遮罩
    float dist = length(vUv - 0.5);
    float circle = step(dist, 0.3);  // 半径0.3的圆
    
    gl_FragColor = vec4(vec3(circle), 1.0);
}

3. smoothstep - S曲线平滑插值

// 基础语法：smoothstep(edge0, edge1, x)
// 当 x < edge0: 返回 0.0
// 当 x > edge1: 返回 1.0
// 当 edge0 < x < edge1: 返回平滑插值（3阶Hermite多项式）

float edge0 = 0.0;
float edge1 = 1.0;
float x = 0.5;
float result = smoothstep(edge0, edge1, x);  // ~0.5（平滑）

// smoothstep的数学公式：
// t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
// return t * t * (3.0 - 2.0 * t);

// 实际应用：边缘软化
varying vec2 vUv;

void main() {
    float dist = length(vUv - 0.5);
    
    // 硬边缘圆（使用step）
    float hardCircle = step(dist, 0.3);
    
    // 软边缘圆（使用smoothstep）
    float softCircle = 1.0 - smoothstep(0.25, 0.35, dist);
    
    gl_FragColor = vec4(vec3(softCircle), 1.0);
}

实用代码示例：

1. 多色渐变

varying vec2 vUv;

void main() {
    vec3 color1 = vec3(1.0, 0.0, 0.0);  // 红
    vec3 color2 = vec3(0.0, 1.0, 0.0);  // 绿
    vec3 color3 = vec3(0.0, 0.0, 1.0);  // 蓝
    
    float t = vUv.x;
    vec3 color;
    
    // 方式1：三段渐变
    if(t < 0.5) {
        color = mix(color1, color2, t * 2.0);
    } else {
        color = mix(color2, color3, (t - 0.5) * 2.0);
    }
    
    // 方式2：使用smoothstep控制权重
    float w1 = smoothstep(0.0, 0.33, t);
    float w2 = smoothstep(0.33, 0.66, t);
    float w3 = smoothstep(0.66, 1.0, t);
    
    color = mix(mix(color1, color2, w1), color3, w2);
    
    gl_FragColor = vec4(color, 1.0);
}

2. 缓动函数

// 自定义easing函数
float easeInQuad(float t) {
    return t * t;
}

float easeOutQuad(float t) {
    return t * (2.0 - t);
}

float easeInOutQuad(float t) {
    return t < 0.5 ? 2.0 * t * t : -1.0 + (4.0 - 2.0 * t) * t;
}

float easeInCubic(float t) {
    return t * t * t;
}

float easeOutCubic(float t) {
    float f = t - 1.0;
    return f * f * f + 1.0;
}

// 指数缓动
float easeInExpo(float t) {
    return t == 0.0 ? 0.0 : pow(2.0, 10.0 * (t - 1.0));
}

// 应用
uniform float time;
varying vec2 vUv;

void main() {
    float t = fract(time);
    float easedT = easeInOutQuad(t);
    
    float y = vUv.y;
    float animatedY = easedT;
    
    float line = smoothstep(animatedY - 0.02, animatedY, y) - 
                 smoothstep(animatedY, animatedY + 0.02, y);
    
    gl_FragColor = vec4(vec3(line), 1.0);
}

3. 柔和阴影/光晕

varying vec2 vUv;
uniform vec2 lightPos;
uniform float lightRadius;
uniform float softness;

void main() {
    float dist = distance(vUv, lightPos);
    
    // 硬边缘光
    float hardLight = step(dist, lightRadius);
    
    // 线性衰减
    float linearLight = 1.0 - clamp(dist / lightRadius, 0.0, 1.0);
    
    // 平滑衰减
    float softLight = 1.0 - smoothstep(0.0, lightRadius, dist);
    
    // 可控软度的光晕
    float innerRadius = lightRadius * (1.0 - softness);
    float glow = 1.0 - smoothstep(innerRadius, lightRadius, dist);
    
    gl_FragColor = vec4(vec3(glow), 1.0);
}

4. 条纹/网格图案

varying vec2 vUv;

void main() {
    // 方式1：硬边缘条纹
    float stripes1 = step(0.5, fract(vUv.x * 10.0));
    
    // 方式2：软边缘条纹
    float t = fract(vUv.x * 10.0);
    float stripes2 = smoothstep(0.4, 0.6, t);
    
    // 网格
    float gridX = step(0.95, fract(vUv.x * 10.0));
    float gridY = step(0.95, fract(vUv.y * 10.0));
    float grid = max(gridX, gridY);
    
    gl_FragColor = vec4(vec3(grid), 1.0);
}

5. 进度条

varying vec2 vUv;
uniform float progress;  // 0.0 到 1.0

void main() {
    // 硬边缘进度条
    float bar1 = step(vUv.x, progress);
    
    // 软边缘进度条
    float bar2 = smoothstep(vUv.x - 0.02, vUv.x + 0.02, progress);
    
    // 带边框的进度条
    float barHeight = step(0.4, vUv.y) - step(0.6, vUv.y);
    float barFill = step(vUv.x, progress);
    float barOutline = step(0.38, vUv.y) - step(0.62, vUv.y);
    
    vec3 fillColor = vec3(0.2, 0.8, 0.3);
    vec3 bgColor = vec3(0.1);
    vec3 outlineColor = vec3(1.0);
    
    vec3 color = mix(bgColor, fillColor, barFill * barHeight);
    color = mix(color, outlineColor, barOutline * (1.0 - barHeight));
    
    gl_FragColor = vec4(color, 1.0);
}

6. 阈值和遮罩

precision mediump float;

uniform sampler2D diffuseMap;
uniform sampler2D maskMap;
uniform float threshold;
uniform float feather;

varying vec2 vUv;

void main() {
    vec4 color = texture2D(diffuseMap, vUv);
    float mask = texture2D(maskMap, vUv).r;
    
    // 硬阈值
    float hardMask = step(threshold, mask);
    
    // 软阈值
    float softMask = smoothstep(threshold - feather, threshold + feather, mask);
    
    // 应用遮罩
    color.a *= softMask;
    
    gl_FragColor = color;
}

7. 距离场字体渲染

precision mediump float;

uniform sampler2D fontAtlas;  // 距离场纹理
uniform float smoothing;

varying vec2 vUv;

void main() {
    float dist = texture2D(fontAtlas, vUv).a;
    
    // 使用smoothstep实现抗锯齿边缘
    float alpha = smoothstep(0.5 - smoothing, 0.5 + smoothing, dist);
    
    vec3 color = vec3(1.0);
    gl_FragColor = vec4(color, alpha);
}

8. 渐变与混合模式

varying vec2 vUv;

void main() {
    // 线性渐变
    vec3 gradient = vec3(vUv.x);
    
    // 径向渐变
    float radial = length(vUv - 0.5);
    vec3 radialGradient = vec3(1.0 - radial * 2.0);
    
    // 角度渐变
    float angle = atan(vUv.y - 0.5, vUv.x - 0.5);
    vec3 angularGradient = vec3((angle + 3.14159) / (2.0 * 3.14159));
    
    // 平滑的菱形渐变
    vec2 center = vUv - 0.5;
    float diamond = abs(center.x) + abs(center.y);
    vec3 diamondGradient = vec3(1.0 - smoothstep(0.0, 0.7, diamond));
    
    gl_FragColor = vec4(diamondGradient, 1.0);
}

插值函数对比：

性能优化：

// 优化1：避免重复计算
// 不好
void main() {
    float c1 = smoothstep(0.0, 1.0, vUv.x);
    float c2 = smoothstep(0.0, 1.0, vUv.x);  // 重复计算
}

// 好
void main() {
    float c = smoothstep(0.0, 1.0, vUv.x);
    // 复用c
}

// 优化2：使用内置函数而非手动实现
// 不好：手动实现smoothstep
float mySmoothstep(float e0, float e1, float x) {
    float t = clamp((x - e0) / (e1 - e0), 0.0, 1.0);
    return t * t * (3.0 - 2.0 * t);
}

// 好：使用内置函数
float result = smoothstep(e0, e1, x);

实际应用场景：

• UI渲染：进度条、按钮状态、过渡动画
• 特效：光晕、辉光、边缘高亮
• 纹理混合：地形材质、天气效果
• 后处理：晕影、色彩分级、过渡效果
• 程序化生成：图案、噪声、距离场
• 动画：缓动、关键帧插值

How to implement Lambert diffuse lighting model in shaders?

考察点：漫反射计算。

答案：

Lambert漫反射是最基础的光照模型，基于物理观察：表面接收的光照强度与光线方向和表面法向量夹角的余弦值成正比。它简单高效，广泛应用于实时渲染中。

Lambert漫反射原理：

Lambert定律（余弦定律）：

Diffuse = max(dot(N, L), 0.0) * lightColor * materialColor

其中：

• N：归一化的表面法向量
• L：归一化的光源方向（从表面指向光源）
• dot(N, L)：计算两向量夹角的余弦值
• max(..., 0.0)：确保背面不被照亮

基础实现：

顶点着色器

attribute vec3 position;
attribute vec3 normal;

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;  // transpose(inverse(mat3(modelMatrix)))

varying vec3 vNormal;
varying vec3 vPosition;

void main() {
    // 变换法向量到世界空间
    vNormal = normalize(normalMatrix * normal);
    
    // 变换顶点位置到世界空间
    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
    vPosition = worldPosition.xyz;
    
    // 计算最终位置
    gl_Position = projectionMatrix * viewMatrix * worldPosition;
}