• 環境光照(Ambient Lighting)：即使在黑暗的情況下，世界上通常也仍然有一些光亮（月亮、遠處的光），所以物體幾乎永遠不會是完全黑暗的。為了模擬這個，我們會使用一個環境光照常量，它永遠會給物體一些顏色。
• 漫反射光照(Diffuse Lighting)：模擬光源對物體的方向性影響(Directional Impact)。它是馮氏光照模型中視覺上最顯著的分量。物體的某一部分越是正對著光源，它就會越亮。
• 鏡面光照(Specular Lighting)：模擬有光澤物體上面出現的亮點。鏡面光照的顏色相比於物體的顏色會更傾向於光的顏色。

• 環境光照

  光通常都不是來自於同一個光源，而是來自於我們周圍分散的很多光源，即使它們可能並不是那麼顯而易見。光的一個屬性是，它可以向很多方向發散並反彈，從而能夠到達不是非常直接臨近的點。所以，光能夠在其它的表面上反射

  ，對一個物體產生間接的影響。考慮到這種情況的演算法叫做全域性照明(Global Illumination)演算法，但是這種演算法既開銷高昂又極其複雜。

  由於我們現在對那種又複雜又開銷高昂的演算法不是很感興趣，所以我們將會先使用一個簡化的全域性照明模型，即環境光照。正如你在上一節所學到的，我們使用一個很小的常量（光照）顏色，新增到物體片段的最終顏色中，這樣子的話即便場景中沒有直接的光源也能看起來存在有一些發散的光。

  把環境光照新增到場景裡非常簡單。我們用光的顏色乘以一個很小的常量環境因子，再乘以物體的顏色，然後將最終結果作為片段的顏色：

  void main()
  {
      float ambientStrength = 0.1;
      vec3 ambient = ambientStrength * lightColor;
  
      vec3 result = ambient * objectColor;
      FragColor = vec4(result, 1.0);
  }
   
  

  如果你現在執行你的程式，你會注意到馮氏光照的第一個階段已經應用到你的物體上了。這個物體非常暗，但由於應用了環境光照（注意光源立方體沒受影響是因為我們對它使用了另一個著色器），也不是完全黑的。它看起來應該像這樣：

  

  漫反射光照

  環境光照本身不能提供最有趣的結果，但是漫反射光照就能開始對物體產生顯著的視覺影響了。漫反射光照使物體上與光線方向越接近的片段能從光源處獲得更多的亮度。為了能夠更好的理解漫反射光照，請看下圖：

  

  圖左上方有一個光源，它所發出的光線落在物體的一個片段上。我們需要測量這個光線是以什麼角度接觸到這個片段的。如果光線垂直於物體表面，這束光對物體的影響會最大化（譯註：更亮）。為了測量光線和片段的角度，我們使用一個叫做法向量(Normal Vector)的東西，它是垂直於片段表面的一個向量（這裡以黃色箭頭表示），我們在後面再講這個東西。這兩個向量之間的角度很容易就能夠通過點乘計算出來。

  你可能記得在變換那一節教程裡，我們知道兩個單位向量的夾角越小，它們點乘的結果越傾向於1。當兩個向量的夾角為90度的時候，點乘會變為0。這同樣適用於θθ，θθ越大，光對片段顏色的影響就應該越小。

  注意，為了（只）得到兩個向量夾角的餘弦值，我們使用的是單位向量（長度為1的向量），所以我們需要確保所有的向量都是標準化的，否則點乘返回的就不僅僅是餘弦值了（見變換）。

  點乘返回一個標量，我們可以用它計算光線對片段顏色的影響。不同片段朝向光源的方向的不同，這些片段被照亮的情況也不同。

  所以，計算漫反射光照需要什麼？

• 法向量：一個垂直於頂點表面的向量。
• 定向的光線：作為光源的位置與片段的位置之間向量差的方向向量。為了計算這個光線，我們需要光的位置向量和片段的位置向量。

• 法向量

  法向量是一個垂直於頂點表面的（單位）向量。由於頂點本身並沒有表面（它只是空間中一個獨立的點），我們利用它周圍的頂點來計算出這個頂點的表面。我們能夠使用一個小技巧，使用叉乘對立方體所有的頂點計算法向量，但是由於3D立方體不是一個複雜的形狀，所以我們可以簡單地把法線資料手工新增到頂點資料中。更新後的頂點資料陣列可以在這裡找到。試著去想象一下，這些法向量真的是垂直於立方體各個平面的表面的（一個立方體由6個平面組成）。

  由於我們向頂點陣列添加了額外的資料，所以我們應該更新光照的頂點著色器：

  #version 330 core
  layout (location = 0) in vec3 aPos;
  layout (location = 1) in vec3 aNormal;
  ...
  

  現在我們已經向每個頂點添加了一個法向量並更新了頂點著色器，我們還要更新頂點屬性指標。注意，燈使用同樣的頂點陣列作為它的頂點資料，然而燈的著色器並沒有使用新新增的法向量。我們不需要更新燈的著色器或者是屬性的配置，但是我們必須至少修改一下頂點屬性指標來適應新的頂點陣列的大小：

  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
  glEnableVertexAttribArray(0);
  

  我們只想使用每個頂點的前三個float，並且忽略後三個float，所以我們只需要把步長引數改成float大小的6倍就行了。

  雖然對燈的著色器使用不能完全利用的頂點資料看起來不是那麼高效，但這些頂點資料已經從箱子物件載入後開始就儲存在GPU的記憶體裡了，所以我們並不需要儲存新資料到GPU記憶體中。這實際上比給燈專門分配一個新的VBO更高效了。

  所有光照的計算都是在片段著色器裡進行，所以我們需要將法向量由頂點著色器傳遞到片段著色器。我們這麼做：

  out vec3 Normal;
  
  void main()
  {
      gl_Position = projection * view * model * vec4(aPos, 1.0);
      Normal = aNormal;
  }
  

  接下來，在片段著色器中定義相應的輸入變數：

  in vec3 Normal;
  

  計算漫反射光照

  我們現在對每個頂點都有了法向量，但是我們仍然需要光源的位置向量和片段的位置向量。由於光源的位置是一個靜態變數，我們可以簡單地在片段著色器中把它宣告為uniform：

  uniform vec3 lightPos;
  

  然後在渲染迴圈中（渲染迴圈的外面也可以，因為它不會改變）更新uniform。我們使用在前面宣告的lightPos向量作為光源位置：

  lightingShader.setVec3("lightPos", lightPos);
  

  最後，我們還需要片段的位置。我們會在世界空間中進行所有的光照計算，因此我們需要一個在世界空間中的頂點位置。我們可以通過把頂點位置屬性乘以模型矩陣（不是觀察和投影矩陣）來把它變換到世界空間座標。這個在頂點著色器中很容易完成，所以我們宣告一個輸出變數，並計算它的世界空間座標：

  out vec3 FragPos;  
  out vec3 Normal;
  
  void main()
  {
      gl_Position = projection * view * model * vec4(aPos, 1.0);
      FragPos = vec3(model * vec4(aPos, 1.0));
      Normal = aNormal;
  }
  

  最後，在片段著色器中新增相應的輸入變數。

  in vec3 FragPos;
  

  現在，所有需要的變數都設定好了，我們可以在片段著色器中新增光照計算了。

  我們需要做的第一件事是計算光源和片段位置之間的方向向量。前面提到，光的方向向量是光源位置向量與片段位置向量之間的向量差。你可能記得在變換教程中，我們能夠簡單地通過讓兩個向量相減的方式計算向量差。我們同樣希望確保所有相關向量最後都轉換為單位向量，所以我們把法線和最終的方向向量都進行標準化：

  vec3 norm = normalize(Normal);
  vec3 lightDir = normalize(lightPos - FragPos);
  

  當計算光照時我們通常不關心一個向量的模長或它的位置，我們只關心它們的方向。所以，幾乎所有的計算都使用單位向量完成，因為這簡化了大部分的計算（比如點乘）。所以當進行光照計算時，確保你總是對相關向量進行標準化，來保證它們是真正地單位向量。忘記對向量進行標準化是一個十分常見的錯誤。

  下一步，我們對norm和lightDir向量進行點乘，計算光源對當前片段實際的漫發射影響。結果值再乘以光的顏色，得到漫反射分量。兩個向量之間的角度越大，漫反射分量就會越小：

  float diff = max(dot(norm, lightDir), 0.0);
  vec3 diffuse = diff * lightColor;
  

  如果兩個向量之間的角度大於90度，點乘的結果就會變成負數，這樣會導致漫反射分量變為負數。為此，我們使用max函式返回兩個引數之間較大的引數，從而保證漫反射分量不會變成負數。負數顏色的光照是沒有定義的，所以最好避免它，除非你是那種古怪的藝術家。

  現在我們有了環境光分量和漫反射分量，我們把它們相加，然後把結果乘以物體的顏色，來獲得片段最後的輸出顏色。

  vec3 result = (ambient + diffuse) * objectColor;
  FragColor = vec4(result, 1.0);
  

  如果你的應用(和著色器)編譯成功了，你可能看到類似的輸出：

  

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <learnopengl/filesystem.h>
#include <learnopengl/shader_m.h>
#include <learnopengl/camera.h>
#include <iostream>

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

// camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
float lastX = SCR_WIDTH / 2.0f;
float lastY = SCR_HEIGHT / 2.0f;
bool firstMouse = true;

// timing
float deltaTime = 0.0f;	
float lastFrame = 0.0f;

// lighting
glm::vec3 lightPos(9.2f, 1.0f, 2.0f);

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
void processInput(GLFWwindow *window)
{
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
		glfwSetWindowShouldClose(window, true);

	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
		camera.ProcessKeyboard(FORWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
		camera.ProcessKeyboard(BACKWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
		camera.ProcessKeyboard(LEFT, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
		camera.ProcessKeyboard(RIGHT, deltaTime);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	// make sure the viewport matches the new window dimensions; note that width and 
	// height will be significantly larger than specified on retina displays.
	glViewport(0, 0, width, height);
}


// glfw: whenever the mouse moves, this callback is called
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	if (firstMouse)
	{
		lastX = xpos;
		lastY = ypos;
		firstMouse = false;
	}

	float xoffset = xpos - lastX;
	float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

	lastX = xpos;
	lastY = ypos;

	camera.ProcessMouseMovement(xoffset, yoffset);
}

// glfw: whenever the mouse scroll wheel scrolls, this callback is called
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
	camera.ProcessMouseScroll(yoffset);
}

int main()
{
    // glfw: initialize and configure
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // glfw window creation
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);
	// tell GLFW to capture our mouse
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    // glad: load all OpenGL function pointers
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // configure global opengl state
    glEnable(GL_DEPTH_TEST);

    // build and compile our shader zprogram
    Shader lightingShader("2.1.basic_lighting.vs", "2.1.basic_lighting.fs");
    Shader lampShader("2.1.lamp.vs", "2.1.lamp.fs");

    // set up vertex data (and buffer(s)) and configure vertex attributes
    float vertices[] = {
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,

        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,

         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
         0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
         0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
         0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,

        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
    };
    // first, configure the cube's VAO (and VBO)
    unsigned int VBO, cubeVAO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &VBO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindVertexArray(cubeVAO);

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // normal attribute
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);


    // second, configure the light's VAO (VBO stays the same; the vertices are the same for the light object which is also a 3D cube)
    unsigned int lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // note that we update the lamp's position attribute's stride to reflect the updated buffer data
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);


    // render loop
    while (!glfwWindowShouldClose(window))
    {
        // per-frame time logic
        float currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // input
        processInput(window);

        // render
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
        lightingShader.use();
        lightingShader.setVec3("objectColor", 1.0f, 0.5f, 0.31f);
        lightingShader.setVec3("lightColor", 1.0f, 1.0f, 1.0f);
        lightingShader.setVec3("lightPos", lightPos);

        // view/projection transformations
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        glm::mat4 view = camera.GetViewMatrix();
        lightingShader.setMat4("projection", projection);
        lightingShader.setMat4("view", view);

        // world transformation
        glm::mat4 model;
        lightingShader.setMat4("model", model);

        // render the cube
        glBindVertexArray(cubeVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // also draw the lamp object
        lampShader.use();
        lampShader.setMat4("projection", projection);
        lampShader.setMat4("view", view);
        model = glm::mat4();
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(0.2f)); // a smaller cube
        lampShader.setMat4("model", model);

        glBindVertexArray(lightVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        glfwSwapBuffers(window);
        glfwPollEvents();	
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
	glfwSetCursorPosCallback(window, mouse_callback);
	glfwSetScrollCallback(window, scroll_callback);
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    glDeleteVertexArrays(1, &cubeVAO);
    glDeleteVertexArrays(1, &lightVAO);
    glDeleteBuffers(1, &VBO);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    glfwTerminate();
    return 0;
}

cube片元著色器：

#version 330 core
out vec4 FragColor;

in vec3 Normal;  
in vec3 FragPos;  
  
uniform vec3 lightPos; 
uniform vec3 lightColor;
uniform vec3 objectColor;

void main()
{
    // ambient
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;
  	
    // diffuse 
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(lightPos - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = diff * lightColor;
            
    vec3 result = (ambient + diffuse) * objectColor;
    FragColor = vec4(result, 1.0);
} 

如何鏡面反射？

現在我們已經把法向量從頂點著色器傳到了片段著色器。可是，目前片段著色器裡的計算都是在世界空間座標中進行的。所以，我們是不是應該把法向量也轉換為世界空間座標？基本正確，但是這不是簡單地把它乘以一個模型矩陣就能搞定的。

首先，法向量只是一個方向向量，不能表達空間中的特定位置。同時，法向量沒有齊次座標（頂點位置中的w分量）。這意味著，位移不應該影響到法向量。因此，如果我們打算把法向量乘以一個模型矩陣，我們就要從矩陣中移除位移部分，只選用模型矩陣左上角3×3的矩陣（注意，我們也可以把法向量的w分量設定為0，再乘以4×4矩陣；這同樣可以移除位移）。對於法向量，我們只希望對它實施縮放和旋轉變換。

其次，如果模型矩陣執行了不等比縮放，頂點的改變會導致法向量不再垂直於表面了。因此，我們不能用這樣的模型矩陣來變換法向量。下面的圖展示了應用了不等比縮放的模型矩陣對法向量的影響：

每當我們應用一個不等比縮放時（注意：等比縮放不會破壞法線，因為法線的方向沒被改變，僅僅改變了法線的長度，而這很容易通過標準化來修復），法向量就不會再垂直於對應的表面了，這樣光照就會被破壞。

修復這個行為的訣竅是使用一個為法向量專門定製的模型矩陣。這個矩陣稱之為法線矩陣(Normal Matrix)，它使用了一些線性代數的操作來移除對法向量錯誤縮放的影響。如果你想知道這個矩陣是如何計算出來的，建議去閱讀這個文章。

法線矩陣被定義為「模型矩陣左上角的逆矩陣的轉置矩陣」。真是拗口，如果你不明白這是什麼意思，別擔心，我們還沒有討論逆矩陣(Inverse Matrix)和轉置矩陣(Transpose Matrix)。注意，大部分的資源都會將法線矩陣定義為應用到模型-觀察矩陣(Model-view Matrix)上的操作，但是由於我們只在世界空間中進行操作（不是在觀察空間），我們只使用模型矩陣。

在頂點著色器中，我們可以使用inverse和transpose函式自己生成這個法線矩陣，這兩個函式對所有型別矩陣都有效。注意我們還要把被處理過的矩陣強制轉換為3×3矩陣，來保證它失去了位移屬性以及能夠乘以vec3的法向量。

Normal = mat3(transpose(inverse(model))) * aNormal;

在漫反射光照部分，光照表現並沒有問題，這是因為我們沒有對物體本身執行任何縮放操作，所以並不是必須要使用一個法線矩陣，僅僅讓模型矩陣乘以法線也可以。可是，如果你進行了不等比縮放，使用法線矩陣去乘以法向量就是必不可少的了。

即使是對於著色器來說，逆矩陣也是一個開銷比較大的運算，因此，只要可能就應該避免在著色器中進行逆矩陣運算，它們必須為你場景中的每個頂點都進行這樣的處理。用作學習目這樣做是可以的，但是對於一個對效率有要求的應用來說，在繪製之前你最好用CPU計算出法線矩陣，然後通過uniform把值傳遞給著色器（像模型矩陣一樣）。

我們通過反射法向量周圍光的方向來計算反射向量。然後我們計算反射向量和視線方向的角度差，如果夾角越小，那麼鏡面光的影響就會越大。它的作用效果就是，當我們去看光被物體所反射的那個方向的時候，我們會看到一個高光。

觀察向量是鏡面光照附加的一個變數，我們可以使用觀察者世界空間位置和片段的位置來計算它。之後，我們計算鏡面光強度，用它乘以光源的顏色，再將它加上環境光和漫反射分量。

我們選擇在世界空間進行光照計算，但是大多數人趨向於在觀察空間進行光照計算。在觀察空間計算的好處是，觀察者的位置總是(0, 0, 0)，所以這樣你直接就獲得了觀察者位置。可是我發現在學習的時候在世界空間中計算光照更符合直覺。如果你仍然希望在觀察空間計算光照的話，你需要將所有相關的向量都用觀察矩陣進行變換（記得也要改變法線矩陣）。

為了得到觀察者的世界空間座標，我們簡單地使用攝像機物件的位置座標代替（它當然就是觀察者）。所以我們把另一個uniform新增到片段著色器，把相應的攝像機位置座標傳給片段著色器：

uniform vec3 viewPos;

lightingShader.setVec3("viewPos", camera.Position);

現在我們已經獲得所有需要的變數，可以計算高光強度了。首先，我們定義一個鏡面強度(Specular Intensity)變數，給鏡面高光一箇中等亮度顏色，讓它不要產生過度的影響。

float specularStrength = 0.5;

如果我們把它設定為1.0f，我們會得到一個非常亮的鏡面光分量，這對於一個珊瑚色的立方體來說有點太多了。下一節教程中我們會討論如何合理設定這些光照強度，以及它們是如何影響物體的。下一步，我們計算視線方向向量，和對應的沿著法線軸的反射向量：

vec3 viewDir = normalize(viewPos - FragPos);
vec3 reflectDir = reflect(-lightDir, norm);

需要注意的是我們對lightDir向量進行了取反。reflect函式要求第一個向量是從光源指向片段位置的向量，但是lightDir當前正好相反，是從片段指向光源（由先前我們計算lightDir向量時，減法的順序決定）。為了保證我們得到正確的reflect向量，我們通過對lightDir向量取反來獲得相反的方向。第二個引數要求是一個法向量，所以我們提供的是已標準化的norm向量。

剩下要做的是計算鏡面分量。下面的程式碼完成了這件事：

float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
vec3 specular = specularStrength * spec * lightColor;

我們先計算視線方向與反射方向的點乘（並確保它不是負值），然後取它的32次冪。這個32是高光的反光度(Shininess)。一個物體的反光度越高，反射光的能力越強，散射得越少，高光點就會越小。在下面的圖片裡，你會看到不同反光度的視覺效果影響：

我們不希望鏡面成分過於顯眼，所以我們把指數保持為32。剩下的最後一件事情是把它加到環境光分量和漫反射分量裡，再用結果乘以物體的顏色：

vec3 result = (ambient + diffuse + specular) * objectColor;
FragColor = vec4(result, 1.0);

我們現在為馮氏光照計算了全部的光照分量。根據你的視角，你可以看到類似下面的畫面：

片元著色器

#version 330 core
out vec4 FragColor;

in vec3 Normal;  
in vec3 FragPos;  
  
uniform vec3 lightPos; 
uniform vec3 viewPos; 
uniform vec3 lightColor;
uniform vec3 objectColor;

void main()
{
    // ambient
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;
  	
    // diffuse 
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(lightPos - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = diff * lightColor;
    
    // specular
    float specularStrength = 0.5;
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 reflectDir = reflect(-lightDir, norm);  
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 512);
    vec3 specular = specularStrength * spec * lightColor;  
        
    vec3 result = (ambient + diffuse + specular) * objectColor;
    FragColor = vec4(result, 1.0);
}