散射和高光范围的关系#

散射是指光线射入物体内部，经过内部散射后再从物体表面射出，入射点与出射点通常不是同一点。

散射强：大量光线进入物体内部并从不同位置射出，光线分布更分散，最终表现为高光范围更大、更柔和。
散射弱：光线极少进入物体内部，大部分光线直接在物体表面镜面反射，入射点与出射点基本一致，最终表现为高光范围更小、更集中。

Phong 材质的四大核心属性#

Phong 光照模型通过四组参数完整定义一个物体的材质特性，分别控制环境光、漫反射、镜面高光表现与高光散射范围：

ambient（环境光颜色）：定义物体在环境光照射下反射的颜色，一般与物体固有色保持一致。
diffuse（漫反射颜色）：定义物体在漫反射光照下呈现的固有色，是物体最主要的显色来源。
specular（镜面高光颜色）：定义物体表面镜面高光区域的反射颜色。
shininess（高光幂次）：控制镜面高光的散射半径，数值越大，高光范围越小、越锐利；数值越小，高光越宽泛、柔和。

材质系统引入前后的光照计算区别#

未引入材质系统#

环境光、漫反射、镜面光三个分量的基础颜色仅为光源颜色，仅有强度系数差异，不包含物体本身颜色信息。因此最终输出颜色需要光照计算结果 × 物体固有色。

引入材质系统后#

材质的 ambient、diffuse、specular 向量本身已经携带并定义了物体的反射色彩，已经包含物体固有色信息。因此最终颜色直接三分量光照结果叠加求和，不再额外乘以物体颜色。

光照分量强度系数的真实作用#

基础 Phong 公式中，光照分量强度仅由计算系数决定。若环境光系数为 1，会导致环境光对画面颜色影响过大，不符合真实物理光照效果。因此真实渲染优化方案：为环境光、漫反射、镜面光分别配置独立强度系数（向量），替代单纯的光源颜色，用来控制各分量对最终颜色的贡献权重。取值经验规则：

环境光：设置较低强度，避免画面过曝、泛白。
漫反射：设置为物体真实固有色，主导物体视觉表现。
镜面高光：通常设为满强度 vec3(1.0)，保证高光亮度正常。补充：光照颜色向量既可以代表反射颜色，也可以代表对应光照分量的强度权重。

example1: 实现一个简单的材质系统（适配phong模型）#

在phong模型中，一个物体受到的光照包含三个部分，分别是环境光、漫反射和镜面反射。上面的实现中，三种分量的颜色都是光源颜色，只是强度略有不同。现在我们直接指定三种分量的颜色，并抽离成一个材质结构体，通过改变三分量的颜色以及反光度，可以实现多样的材质效果。 BQACAgUAAyEGAASHRsPbAAEWKlJqP1XrilcnYFhrZTlxr6zky_y2OQACUSMAAk05AVYX1j96mdoiITwE.png

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 1) in vec3 aNormal;
5

6
out vec3 worldPos;
7
out vec3 normal;
8

9
uniform mat4 model;
10
uniform mat4 view;
11
uniform mat4 project;
12
void main(){
13
        gl_Position=project*view*model*vec4(aPos,1.0);
14
        worldPos=vec3(model*vec4(aPos,1.0));
15
        normal = mat3(transpose(inverse(model)))*aNormal;
16
}

1
//fragmentShader
2
#version 330 core
3
struct Material{
4
        vec3 ambient;
5
        vec3 diffuse;
6
        vec3 specular;
7
        float shininess;
8
};
9
in vec3 worldPos;
10
in vec3 normal;
11
uniform Material material;
12
uniform vec3 lightPos;
13
uniform vec3 viewPos;
14
uniform vec3 lightColor;
15
out vec4 FragColor;
16
void main(){
17
        vec3 ambient = lightColor*material.ambient;
18

19
        vec3 worldNormal=normalize(normal);
20
        vec3 worldLightDir=normalize(lightPos-worldPos);
21
        float diff=max(dot(worldNormal,worldLightDir),0.0);
22
        vec3 diffuse=diff*material.diffuse*lightColor;
23

24
        vec3 worldViewDir=normalize(viewPos-worldPos);
25
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
26
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0),material.shininess);
27
        vec3 specular=spec*material.specular*lightColor;
28

29
        FragColor = vec4(ambient+diffuse+specular,1.0);
30
}

1
Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
2

3
ourShader.use();
4
//设置uniform变量值
5
ourShader.setVec3("objectColor", glm::vec3(1.0f, 0.5f, 0.31f));
6
ourShader.setVec3("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
7

8
ourShader.setVec3("material.ambient", glm::vec3(1.0f, 0.5f, 0.31f));
9
ourShader.setVec3("material.diffuse", glm::vec3(1.0f, 0.5f, 0.31f));
10
ourShader.setVec3("material.specular", glm::vec3(0.5f, 0.5f, 0.5f));
11
ourShader.setFloat("material.shininess", 32.0f);
12

13
while (!glfwWindowShouldClose(window)) {
14
    float currentFrame = static_cast<float>(glfwGetTime());
15
    deltaTime = currentFrame - lastFrame;
16
    lastFrame = currentFrame;
17
        processInput(window);
18
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
19
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
20

21
    //绘制物体
22
    ourShader.use();
23
    glBindVertexArray(VAO);
24
    ourShader.setVec3("lightPos", lightPos);//把新光源的位置传递给物体
25

26
    glm::mat4 model;
27
    ourShader.setMatrix("model", model);
28
    glm::mat4 view;
29
    view = camera.GetCameraView();
30
    ourShader.setMatrix("view", view);
31
    glm::mat4 project;
32
    project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
33
    ourShader.setMatrix("project", project);
34
    ourShader.setVec3("viewPos", camera.Position);//运行后，相机会移动，视角也会随之移动，也就是说视角是变化的，那么设置viewPos的语句就应该写在循环内
35
    glDrawArrays(GL_TRIANGLES, 0, 36);
36

37
    //绘制灯
38
    lightShader.use();
39
    glBindVertexArray(lightVAO);
40
    model = glm::mat4();
41
    model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
42
    model = glm::scale(model, glm::vec3(0.2f));
43
    lightShader.setMatrix("model", model);
44
    lightShader.setMatrix("view", view);
45
    lightShader.setMatrix("project", project);
46
    glDrawArrays(GL_TRIANGLES, 0, 36);
47

48
    glfwSwapBuffers(window);
49
    glfwPollEvents();
50
}

现在我们发现，物体似乎太亮了。原因在于，环境光、漫反射光以及镜面反射光，都是乘以完完全全、一整份光源颜色，所以他们对每个光源都是全力反射的，场景中只有一份光源，但是却反射出了三份光，所以物体看起来偏亮。解决思路就是给每个分量分一个比例，这个比例表示该分量对于光源的反射强度。

example2: 抽离出光源结构体#

对每个分量，使用一个向量控制这个分量在最终颜色中的比例。这个vec3向量是颜色和强度的二合一（light.ambient=lightColor*ambientStrength）。 BQACAgUAAyEGAASHRsPbAAEWKlxqP1Zc6dFoBoyj0skdjadAnFm8ygACXCMAAk05AVZmuXQVr-V6ujwE.png

1
//fragmentShader
2
#version 330 core
3
struct Material{
4
        //编码了物体颜色
5
        vec3 ambient;//物体本身对环境光的反射率
6
        vec3 diffuse;//物体本身对漫反射光的反射率
7
        vec3 specular;//物体本身的高光颜色
8
        float shininess;
9
};
10
struct Light{
11
        //编码了灯光颜色
12
        vec3 lightPos;
13
        vec3 ambient;//环境光的强度和颜色
14
        vec3 diffuse;//漫反射光的强度和颜色
15
        vec3 specular;//高光的强度和颜色
16
};
17
//物体最终颜色=系数*物体颜色*光源颜色
18
in vec3 worldPos;
19
in vec3 normal;
20
uniform Material material;
21
uniform Light light;
22
uniform vec3 viewPos;
23
out vec4 FragColor;
24
void main(){
25
        vec3 ambient = light.ambient*material.ambient;
26

27
        vec3 worldNormal=normalize(normal);
28
        vec3 worldLightDir=normalize(light.lightPos-worldPos);
29
        float diff=max(dot(worldNormal,worldLightDir),0.0);
30
        vec3 diffuse=diff*material.diffuse*light.diffuse;
31

32
        vec3 worldViewDir=normalize(viewPos-worldPos);
33
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
34
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0),material.shininess);
35
        vec3 specular=spec*material.specular*light.specular;
36

37
        FragColor = vec4(ambient+diffuse+specular,1.0);
38
}

1
ourShader.setVec3("light.ambient", glm::vec3(0.2f, 0.2f, 0.2f));
2
ourShader.setVec3("light.diffuse", glm::vec3(0.5f, 0.5f, 0.5f));
3
ourShader.setVec3("light.specular", glm::vec3(1.0f, 1.0f, 1.0f));
4

5
while (!glfwWindowShouldClose(window)) {
6
    float currentFrame = static_cast<float>(glfwGetTime());
7
    deltaTime = currentFrame - lastFrame;
8
    lastFrame = currentFrame;
9
        processInput(window);
10
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
11
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
12

13
    //绘制物体
14
    ourShader.use();
15
    glBindVertexArray(VAO);
16
    ourShader.setVec3("light.lightPos", lightPos);//把新光源的位置传递给物体
17

18
    glm::mat4 model;
19
    ourShader.setMatrix("model", model);
20
    glm::mat4 view;
21
    view = camera.GetCameraView();
22
    ourShader.setMatrix("view", view);
23
    glm::mat4 project;
24
    project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
25
    ourShader.setMatrix("project", project);
26
    ourShader.setVec3("viewPos", camera.Position);//运行后，相机会移动，视角也会随之移动，也就是说视角是变化的，那么设置viewPos的语句就应该写在循环内
27
    glDrawArrays(GL_TRIANGLES, 0, 36);
28

29
    //绘制灯
30
    lightShader.use();
31
    glBindVertexArray(lightVAO);
32
    model = glm::mat4();
33
    model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
34
    model = glm::scale(model, glm::vec3(0.2f));
35
    lightShader.setMatrix("model", model);
36
    lightShader.setMatrix("view", view);
37
    lightShader.setMatrix("project", project);
38
    glDrawArrays(GL_TRIANGLES, 0, 36);
39

40
    glfwSwapBuffers(window);
41
    glfwPollEvents();
42
}

example3: 让光源颜色不断变化#

在渲染循环中使用sin函数，并使用glfwGetTime()获取运行时间作为自变量，计算lightColor三分量。然后赋值给diffuseColor和ambientColor，让场景中的光源颜色不断变化，观察物体表面颜色的变化。物体表面颜色随着光源颜色的变化而变化，这是因为物体的漫反射颜色=光源颜色*漫反射率，漫反射率决定了物体对光源颜色中RGB三分量的反射比例，而反射出来的光被人眼感知，认为是物体的颜色。

1
//物体的着色器
2
Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
3
//光源的着色器
4
//如果共用一个片元着色器，修改物体颜色将会修改光源颜色，这并不是我们想要的
5
Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
6

7
ourShader.use();
8
//设置uniform变量值
9
ourShader.setVec3("material.ambient", glm::vec3(1.0f, 0.5f, 0.31f));
10
ourShader.setVec3("material.diffuse", glm::vec3(1.0f, 0.5f, 0.31f));
11
ourShader.setVec3("material.specular", glm::vec3(0.5f, 0.5f, 0.5f));
12
ourShader.setFloat("material.shininess", 32.0f);
13

14
while (!glfwWindowShouldClose(window)) {
15
    float currentFrame = static_cast<float>(glfwGetTime());
16
    deltaTime = currentFrame - lastFrame;
17
    lastFrame = currentFrame;
18
        processInput(window);
19
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
20
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
21

22
    //绘制物体
23
    ourShader.use();
24
    glBindVertexArray(VAO);
25

26
    glm::mat4 model;
27
    ourShader.setMatrix("model", model);
28
    glm::mat4 view;
29
    view = camera.GetCameraView();
30
    ourShader.setMatrix("view", view);
31
    glm::mat4 project;
32
    project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
33
    ourShader.setMatrix("project", project);
34

35
    //传递物体运行时需要更新的uniform变量
36
    ourShader.setVec3("viewPos", camera.Position);
37
    ourShader.setVec3("light.lightPos", lightPos);
38

39
    glm::vec3 lightColor;
40
    lightColor.x = static_cast<float>(sin(glfwGetTime() * 2.0));//计算光源颜色时需要用到运行时间，那么计算光源颜色的逻辑就必须写在渲染循环内部
41
    lightColor.y = static_cast<float>(sin(glfwGetTime() * 0.7));
42
    lightColor.z = static_cast<float>(sin(glfwGetTime() * 1.3));//让光源颜色的RGB分量以不同的速度变化，产生多样的颜色组合。如果是同步变化，则只能是从黑到白的过渡
43

44
    glm::vec3 diffuseColor = lightColor * glm::vec3(0.5f);//直接把lightColor作为漫反射光会太亮，乘以0.5压低亮度
45
    glm::vec3 ambientColor = diffuseColor * glm::vec3(0.2f);//环境光通常来自漫反射光的多次反弹，所以由diffuseColor计算，且环境光通常比较暗，所以需要进一步压低亮度
46
    ourShader.setVec3("light.ambient", ambientColor);
47
    ourShader.setVec3("light.diffuse", diffuseColor);//使用新计算出来的漫反射和环境光赋值光照结构体的相关变量
48
    ourShader.setVec3("light.specular", glm::vec3(1.0f, 1.0f, 1.0f));//高光保持全白、最大亮度
49
    glDrawArrays(GL_TRIANGLES, 0, 36);
50

51
    //绘制灯
52
    lightShader.use();
53
    glBindVertexArray(lightVAO);
54
    model = glm::mat4();
55
    model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
56
    model = glm::scale(model, glm::vec3(0.2f));
57
    lightShader.setMatrix("model", model);
58
    lightShader.setMatrix("view", view);
59
    lightShader.setMatrix("project", project);
60
    glDrawArrays(GL_TRIANGLES, 0, 36);
61

62
    glfwSwapBuffers(window);
63
    glfwPollEvents();
64
}

homework#

你能像教程一开始那样，通过定义相应的材质来模拟现实世界的物体吗？注意材质表格中的环境光值与漫反射值不一样，它们没有考虑光照的强度。要想正确地设置它们的值，你需要将所有的光照强度都设置为vec3(1.0)，这样才能得到一致的输出。思路：材质表格中的各个字段设置的应该是Material结构体内的对应字段，而非Light结构体。此外，根据题目说明，材质表中的值没有考虑光照强度，也就是所有光照强度都是默认的1，即需要把light.ambient/light.diffuse/light.specular都设置为vec3(1.0)。 BQACAgUAAyEGAASHRsPbAAEWKmFqP1bukPX8TqWwVD9MolwPuv6xnAACYiMAAk05AVa1exn8j1BSGzwE.png

1
ourShader.setVec3("material.ambient", glm::vec3(0.0f, 0.1f, 0.06f));
2
ourShader.setVec3("material.diffuse", glm::vec3(0.0f, 0.50980392f, 0.50980392f));
3
ourShader.setVec3("material.specular", glm::vec3(0.50196078f, 0.50196078f, 0.50196078f));
4
ourShader.setFloat("material.shininess", 0.25f * 128.0);
5
//因为以上材质参数在运行时不需要改变，所以可以写在渲染循环外面