OpenGL学习笔记——光照(一)

朴灿烈づ我的快乐病毒、 2023-01-14 00:47 157阅读 0赞

### 文章目录 ###

*  一、颜色
 *  二、光照基础
 *   *  2.1环境光照
     *  2.2漫反射光照
     *  2.3镜面光照

> 如何才能更为真实的表现出生活中的环境呢？其实现实生活它已经给了我们答案，就是光照。了解光与颜色构造之间的关系，我们才能更好的创造出更为真实的场景颜色。

# 一、颜色 #

> 其实只要有一些基础的物理知识，我们就可以了解到物体在我们人眼中的颜色是光接触物体之后，物体反射到我们眼中的颜色。理解了这一点下面就比较容易用代码实现了，如下所示：

> Camera.h

#ifndef CAMERA_H
    #define CAMERA_H
    
    #include <glad/glad.h>
    #include "glm/glm.hpp"
    #include "glm/gtc/matrix_transform.hpp"
    
    #include <vector>
    
    //定义相机移动的选项
    enum Camera_Movement { 
    	FORWARD,
    	BACKWARD,
    	LEFT,
    	RIGHT
    };
    
    //默认的相机参数
    const float YAW = -90.0f;
    const float PITCH = 0.0f;
    const float SPEED = 2.5f;
    const float SENSITIVITY = 0.1f;
    const float ZOOM = 45.0f;
    
    //相机类
    class Camera
    { 
    public:
    	// camera Attributes
    	glm::vec3 Position;
    	glm::vec3 Front;
    	glm::vec3 Up;
    	glm::vec3 Right;
    	glm::vec3 WorldUp;
    	// euler Angles
    	float Yaw;
    	float Pitch;
    	// camera options
    	float MovementSpeed;
    	float MouseSensitivity;
    	float Zoom;
    
    	// constructor with vectors
    	Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    	{ 
    		Position = position;
    		WorldUp = up;
    		Yaw = yaw;
    		Pitch = pitch;
    		updateCameraVectors();
    	}
    	// constructor with scalar values
    	Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    	{ 
    		Position = glm::vec3(posX, posY, posZ);
    		WorldUp = glm::vec3(upX, upY, upZ);
    		Yaw = yaw;
    		Pitch = pitch;
    		updateCameraVectors();
    	}
    
    	// returns the view matrix calculated using Euler Angles and the LookAt Matrix
    	glm::mat4 GetViewMatrix()
    	{ 
    		return glm::lookAt(Position, Position + Front, Up);
    	}
    
    	// processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
    	void ProcessKeyboard(Camera_Movement direction, float deltaTime)
    	{ 
    		float velocity = MovementSpeed * deltaTime;
    		if (direction == FORWARD)
    			Position += Front * velocity;
    		if (direction == BACKWARD)
    			Position -= Front * velocity;
    		if (direction == LEFT)
    			Position -= Right * velocity;
    		if (direction == RIGHT)
    			Position += Right * velocity;
    	}
    
    	// processes input received from a mouse input system. Expects the offset value in both the x and y direction.
    	void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true)
    	{ 
    		xoffset *= MouseSensitivity;
    		yoffset *= MouseSensitivity;
    
    		Yaw += xoffset;
    		Pitch += yoffset;
    
    		// make sure that when pitch is out of bounds, screen doesn't get flipped
    		if (constrainPitch)
    		{ 
    			if (Pitch > 89.0f)
    				Pitch = 89.0f;
    			if (Pitch < -89.0f)
    				Pitch = -89.0f;
    		}
    
    		// update Front, Right and Up Vectors using the updated Euler angles
    		updateCameraVectors();
    	}
    
    	// processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
    	void ProcessMouseScroll(float yoffset)
    	{ 
    		Zoom -= (float)yoffset;
    		if (Zoom < 1.0f)
    			Zoom = 1.0f;
    		if (Zoom > 45.0f)
    			Zoom = 45.0f;
    	}
    
    private:
    	// calculates the front vector from the Camera's (updated) Euler Angles
    	void updateCameraVectors()
    	{ 
    		// calculate the new Front vector
    		glm::vec3 front;
    		front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
    		front.y = sin(glm::radians(Pitch));
    		front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
    		Front = glm::normalize(front);
    		//重新计算相机的右向量与上向量
    		Right = glm::normalize(glm::cross(Front, WorldUp));  // normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
    		Up = glm::normalize(glm::cross(Right, Front));
    	}
    };
    #endif

而关于Shader着色器类已经在前面的文章提过，所以在这里就直接进入正题。

> shader\_light\_cube.vs

#version 330 core
    layout (location = 0) in vec3 aPos;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    void main()
    { 
    	gl_Position = projection * view * model * vec4(aPos, 1.0);
    }

> shader\_light\_cube.fs

#version 330 core
    out vec4 FragColor;
    
    void main()
    { 
        FragColor = vec4(1.0); //设置为白色
    }

> shader\_color\_cube.vs

> shader\_color\_cube.fs

#version 330 core
    out vec4 FragColor;
      
    uniform vec3 objectColor;
    uniform vec3 lightColor;
    
    void main()
    { 
        FragColor = vec4(lightColor * objectColor, 1.0);		//利用反射的原理来计算出物体的颜色
    }

> Practice.h

#pragma once
    
    #include<glad\glad.h>
    #include<GLFW\glfw3.h>
    
    #include"shader.h"
    #include"Camera.h"
    #include<iostream>
    
    namespace Light { 
    	const unsigned int SCR_WIDTH = 800;
    	const unsigned int SCR_HEIGHT = 600;
    
    	Camera camera(glm::vec3(0.0f, 0.0f, 5.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;
    
    	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);
    	}
    
    	//窗口大小发生变化时会调用该函数
    	void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    	{ 
    		glViewport(0, 0, width, height);		//重新设置视口大小
    	}
    
    	//鼠标事件
    	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);
    	}
    
    	//滚轮事件
    	void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
    	{ 
    		camera.ProcessMouseScroll(yoffset);
    	}
    
    	void lightv1() { 
    		glfwInit();
    		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
    		GLFWwindow *window = glfwCreateWindow(800, 600, "Light", 0, 0);
    		if (window==NULL) { 
    			std::cout << "Creating window is failed" << std::endl;
    			glfwTerminate();
    			return;
    		}
    
    		glfwMakeContextCurrent(window);
    		glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    		glfwSetCursorPosCallback(window, mouse_callback);
    		glfwSetScrollCallback(window, scroll_callback);
    		glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
    
    		if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    		{ 
    			std::cout << "Failed to initialize GLAD" << std::endl;
    			return;
    		}
    
    		int viewWidth, viewHeight;
    		glfwGetFramebufferSize(window, &viewWidth, &viewHeight);
    		glViewport(0, 0, viewWidth, viewHeight);
    
    		Shader colorShader("../Shader/shader_color.vs", "../Shader/shader_color.fs");
    		Shader cubeShader("../Shader/shader_light_cube.vs", "../Shader/shader_light_cube.fs");
    
    		//顶点数据
    		float vertices[] = { 
    			-0.5f, -0.5f, -0.5f,
    			0.5f, -0.5f, -0.5f,
    			0.5f,  0.5f, -0.5f,
    			0.5f,  0.5f, -0.5f,
    			-0.5f,  0.5f, -0.5f,
    			-0.5f, -0.5f, -0.5f,
    
    			-0.5f, -0.5f,  0.5f,
    			0.5f, -0.5f,  0.5f,
    			0.5f,  0.5f,  0.5f,
    			0.5f,  0.5f,  0.5f,
    			-0.5f,  0.5f,  0.5f,
    			-0.5f, -0.5f,  0.5f,
    
    			-0.5f,  0.5f,  0.5f,
    			-0.5f,  0.5f, -0.5f,
    			-0.5f, -0.5f, -0.5f,
    			-0.5f, -0.5f, -0.5f,
    			-0.5f, -0.5f,  0.5f,
    			-0.5f,  0.5f,  0.5f,
    
    			0.5f,  0.5f,  0.5f,
    			0.5f,  0.5f, -0.5f,
    			0.5f, -0.5f, -0.5f,
    			0.5f, -0.5f, -0.5f,
    			0.5f, -0.5f,  0.5f,
    			0.5f,  0.5f,  0.5f,
    
    			-0.5f, -0.5f, -0.5f,
    			0.5f, -0.5f, -0.5f,
    			0.5f, -0.5f,  0.5f,
    			0.5f, -0.5f,  0.5f,
    			-0.5f, -0.5f,  0.5f,
    			-0.5f, -0.5f, -0.5f,
    
    			-0.5f,  0.5f, -0.5f,
    			0.5f,  0.5f, -0.5f,
    			0.5f,  0.5f,  0.5f,
    			0.5f,  0.5f,  0.5f,
    			-0.5f,  0.5f,  0.5f,
    			-0.5f,  0.5f, -0.5f,
    		};
    
    		//为数据分配缓冲区
    		unsigned int colorVAO, VBO;
    		glGenVertexArrays(1, &colorVAO);
    		glBindVertexArray(colorVAO);
    
    		glGenBuffers(1, &VBO);
    		glBindBuffer(GL_ARRAY_BUFFER, VBO);
    		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    		glEnableVertexAttribArray(0);
    
    		unsigned int cubeVAO;
    		glGenVertexArrays(1,&cubeVAO);
    		glBindVertexArray(cubeVAO);
    		glBindBuffer(GL_ARRAY_BUFFER, VBO);
    		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    		glEnableVertexAttribArray(0);
    
    		glEnable(GL_DEPTH_TEST);
    		//光源的位置
    		glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
    
    		while (!glfwWindowShouldClose(window)) { 
    			float currentFrame = glfwGetTime();
    			deltaTime = currentFrame - lastFrame;
    			lastFrame = currentFrame;
    			processInput(window);
    			
    			glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
    			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    			glm::mat4 model = glm::mat4(1.0f);
    			glm::mat4 view = glm::mat4(1.0f);
    			glm::mat4 projection = glm::mat4(1.0f);
    
    			//绘制有颜色的立方体
    			colorShader.use();
    			colorShader.setVec3("objectColor", 1.0f, 0.5f, 0.31f);
    			colorShader.setVec3("lightColor", 1.0f, 1.0f, 1.0f);
    			projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    			view = camera.GetViewMatrix();
    			colorShader.setMat4("projection", projection);
    			colorShader.setMat4("view", view);
    			colorShader.setMat4("model", model);
    			glBindVertexArray(colorVAO);
    			glDrawArrays(GL_TRIANGLES, 0, 36);
    
    			//绘制光源立方体
    			cubeShader.use();
    			//view = glm::translate(view, glm::vec3(0.0f, 0.0f, -10.0f));
    			//view = glm::lookAt(glm::vec3(0.0f, 0.0f, 10.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
    			cubeShader.setMat4("projection", projection);
    			cubeShader.setMat4("view", view);
    			model = glm::mat4(1.0f);
    			model = glm::translate(model, lightPos);		//将灯平移到lightPos位置
    			model = glm::scale(model, glm::vec3(0.3f));		//并对其进行一定程度的缩放
    			cubeShader.setMat4("model", model);
    			glBindVertexArray(cubeVAO);
    			glDrawArrays(GL_TRIANGLES, 0, 36);
    
    			glfwSwapBuffers(window);
    			glfwPollEvents();
    		}
    		glDeleteVertexArrays(1, &colorVAO);
    		glDeleteVertexArrays(1, &cubeVAO);
    		glDeleteBuffers(1, &VBO);
    
    		glfwTerminate();
    	}
    }

> main.cpp

#include"Practice.h"
    
    int main() { 
    	Light::lightv1();
    	
    	return 0;
    }

运行效果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]

# 二、光照基础 #

> 这部分主要是学习怎么使用冯氏光照模型：环境(Ambient)、漫反射(Diffuse)和镜面(Specular)光照。

## 2.1环境光照 ##

其实就是添加了一个环境因子来控制光的强度，以此来影响物体反射的颜色。

> shader\_ambient.fs

#version 330 core
    out vec4 FragColor;
      
    uniform vec3 lightColor;
    uniform vec3 objectColor;
    
    void main()
    { 
        //环境因子
        float ambientStrength = 0.3;
        vec3 ambient = ambientStrength * lightColor;  	//利用环境因子来控制光强
        vec3 result = ambient * objectColor;
        FragColor = vec4(result, 1.0);
    }

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]

## 2.2漫反射光照 ##

> 漫反射，是投射在粗糙表面上的光向各个方向反射的现象。但说到底这仍然是一种反射现象，那么其就与物体表面的法向量有着很大的关系，物体表面各点的法向量不一致，才造成了反射光线“漫射”现象，因此冯氏光照模型引入了散射因子这一概念来更好的模拟光照。不过因为本次的对象是一个较为理想的立方体，所以其每个面的法向量默认是一致的，实现过程如下所示。

> shader\_basic\_lighting.vs

#version 330 core
    layout (location = 0) in vec3 aPos;
    layout (location = 1) in vec3 aNormal;
    
    out vec3 FragPos;
    out vec3 Normal;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    void main()
    { 
        FragPos = vec3(model * vec4(aPos, 1.0));		//将局部坐标系中的坐标转化到世界坐标系中，也就求出了片元位置
        Normal = aNormal;  
        
        gl_Position = projection * view * vec4(FragPos, 1.0);
    }

> shader\_basic\_lighting.fs

#version 330 core
    out vec4 FragColor;
    
    in vec3 Normal;  
    in vec3 FragPos;  
      
    uniform vec3 lightPos; 
    uniform vec3 lightColor;
    uniform vec3 objectColor;
    
    void main()
    { 
        //环境因子
        float ambientStrength = 0.1;
        vec3 ambient = ambientStrength * lightColor;
      	
        //散射因子，也就是两个方向夹角的cos值
        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);
    }

CPU端也要进行相应的修改：

Shader colorShader("../Shader/shader_basic_lighting.vs", "../Shader/shader_basic_lighting.fs");
    		Shader cubeShader("../Shader/shader_light_cube.vs", "../Shader/shader_light_cube.fs");
    
    		//顶点数据
    		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
    		};
    
    		//为数据分配缓冲区
    		unsigned int colorVAO, VBO;
    		glGenVertexArrays(1, &colorVAO);
    		glBindVertexArray(colorVAO);
    
    		glGenBuffers(1, &VBO);
    		glBindBuffer(GL_ARRAY_BUFFER, VBO);
    		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    		glEnableVertexAttribArray(0);
    		glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
    		glEnableVertexAttribArray(1);
    
    		unsigned int cubeVAO;
    		glGenVertexArrays(1, &cubeVAO);
    		glBindVertexArray(cubeVAO);
    		glBindBuffer(GL_ARRAY_BUFFER, VBO);
    		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    		glEnableVertexAttribArray(0);
    
    		//光源的位置
    		glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
    
    		while (!glfwWindowShouldClose(window)) { 
    			float currentFrame = glfwGetTime();
    			deltaTime = currentFrame - lastFrame;
    			lastFrame = currentFrame;
    			glEnable(GL_DEPTH_TEST);
    			processInput(window);
    
    			glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
    			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    			glm::mat4 model = glm::mat4(1.0f);
    			glm::mat4 view = glm::mat4(1.0f);
    			glm::mat4 projection = glm::mat4(1.0f);
    
    			//绘制有颜色的立方体
    			colorShader.use();
    			colorShader.setVec3("objectColor", 1.0f, 0.5f, 0.31f);
    			colorShader.setVec3("lightColor", 1.0f, 1.0f, 1.0f);
    			colorShader.setVec3("lightPos", lightPos);
    			projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    			view = camera.GetViewMatrix();
    			colorShader.setMat4("projection", projection);
    			colorShader.setMat4("view", view);
    			colorShader.setMat4("model", model);
    			glBindVertexArray(colorVAO);
    			glDrawArrays(GL_TRIANGLES, 0, 36);
    
    			cubeShader.use();
    			//view = glm::translate(view, glm::vec3(0.0f, 0.0f, -10.0f));
    			//view = glm::lookAt(glm::vec3(0.0f, 0.0f, 10.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
    			cubeShader.setMat4("projection", projection);
    			cubeShader.setMat4("view", view);
    			model = glm::mat4(1.0f);
    			model = glm::translate(model, lightPos);		//将灯平移到lightPos位置
    			model = glm::scale(model, glm::vec3(0.2f));		//并对其进行一定程度的缩放
    			cubeShader.setMat4("model", model);
    			glBindVertexArray(cubeVAO);
    			glDrawArrays(GL_TRIANGLES, 0, 36);
    
    			glfwSwapBuffers(window);
    			glfwPollEvents();
    		}

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 2]

## 2.3镜面光照 ##

> 现实生活中，我们无论在哪一个位置去观测一个表面相对光滑的物体，都会感觉这个物体相较于一些粗糙的物体更亮。其中这主要的原因就是因为镜面光的作用，因此考虑到这一点，冯氏光照模型中通过引入反射向量与人眼视线方向的夹角这一数值因子，来更好的模拟现实中光照对物体颜色的影响，实现过程如下所示。

> shader\_basic\_lighting2.vs

#version 330 core
    layout (location = 0) in vec3 aPos;
    layout (location = 1) in vec3 aNormal;
    
    out vec3 FragPos;
    out vec3 Normal;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    void main()
    { 
        FragPos = vec3(model * vec4(aPos, 1.0));		//将局部坐标系中的坐标转化到世界坐标系中，也就求出了片元位置
        Normal = mat3(transpose(inverse(model))) * aNormal;  	//使用正规矩阵来变换法向量
        
        gl_Position = projection * view * vec4(FragPos, 1.0);
    }

> shader\_basic\_lighting2.fs

#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()
    { 
        //环境光
        float ambientStrength = 0.1;
        vec3 ambient = ambientStrength * lightColor;
      	
        //散射光 
        vec3 norm = normalize(Normal);
        vec3 lightDir = normalize(lightPos - FragPos);
        float diff = max(dot(norm, lightDir), 0.0);
        vec3 diffuse = diff * lightColor;
        
        //镜面光
        float specularStrength = 0.5;	//设置镜面光的强度
        vec3 viewDir = normalize(viewPos - FragPos);	//视线方向
        vec3 reflectDir = reflect(-lightDir, norm);  //第一个参数是指从光源指向片段位置的向量
        float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);	//32是高光的发光值，可以认为是一个物体的反射光的能力
        vec3 specular = specularStrength * spec * lightColor;  	//计算出镜面光的最终结果
            
        vec3 result = (ambient + diffuse + specular) * objectColor;
        FragColor = vec4(result, 1.0);
    }

为了效果可以好一些，我特意修改了一下，光源与相机的位置：

> Camera camera(glm::vec3(-4.0f,2.0f, 5.0f));  
> glm::vec3 lightPos(1.2f, 1.0f, -2.0f);

最后再将相机的位置传递给着色器即可。

> colorShader.setVec3(“viewPos”, camera.Position); //将相机位置（人眼位置）传递给着色器

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 3]

> 参考资料：[《Learning OpenGL》][Learning OpenGL]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]: /images/20221022/47f419c0152f4046aa6ac17c36891eb2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]: /images/20221022/cddef4eedf0d4725962595c54cea273e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 2]: /images/20221022/09e2e4b77df948748b15dfab38299d03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 3]: /images/20221022/2ed270f33c4b442faeaebfa4b06ab59d.png
[Learning OpenGL]: https://learnopengl-cn.readthedocs.io/zh/latest/02%20Lighting/02%20Basic%20Lighting/