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

最新推荐文章于 2022-08-30 20:05:31 发布
最新推荐文章于 2022-08-30 20:05:31 发布
阅读量507 收藏 4
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dayuhaitang1/article/details/115866326
版权

文章目录

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

一、颜色

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

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

#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_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;
}

运行效果：

在这里插入图片描述

二、光照基础

这部分主要是学习怎么使用冯氏光照模型：环境(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);
}

运行效果：
在这里插入图片描述

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();
		}

运行效果：
在这里插入图片描述

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); //将相机位置（人眼位置）传递给着色器

运行效果：
在这里插入图片描述

参考资料：《Learning OpenGL》

大鱼BIGFISH
关注
专栏目录
Opengl-光照-基本光照-材质(有了材质一个物体才算是完整了)
alex1992azh的博客
08-16 1664
在现实世界里，每个物体会对光产生不同的反应。比如说，钢看起来通常会比陶瓷花瓶更闪闪发光，木头箱子也不会像钢制箱子那样对光产生很强的反射。每个物体对镜面高光也有不同的反应。有些物体反射光的时候不会有太多的散射(Scatter)，因而产生一个较小的高光点，而有些物体则会散射很多，产生一个有着更大半径的高光点。如果我们想要在OpenGL中模拟多种类型的物体，我们必须为每个物体分别定义一个材质(Ma...
OpenGL学习脚印: 光照基础(basic lighting)
热门推荐
王定桥的专栏
06-12 1万+
写在前面 上一节坐标变换过程，总结了OpenGL中顶点的处理过程。有了前面的基础，从本节开始，我们可以开始学习OpenGL中包括光照、模型加载等主题。光照是一个复杂的主题，本节学习简单的Phong reflection model.本节示例程序均可以在我的github下载。 本节内容整理自: 1. learnopengl.com Basic Lighting 2.Modern
opengl之光照
lck8989的博客
09-29 372
漫反射光照 环境光照本身不能提供最有趣的结果，但是漫反射光照就能开始对物体产生显著的视觉影响了。漫反射光照使物体上与光线方向越接近的片段能从光源处获得更多的亮度。为了能够更好的理解漫反射光照，请看下图： 图左上方有一个光源，它所发出的光线落在物体的一个片段上。我们需要测量这个光线是以什么角度接触到这个片段的。如果光线垂直于物体表面，这束光对物体的影响会最大化（译注：更亮）。为了测量光线和片...
opengl光照
12-05
关于如何在opengl使用光照来实现各种效果
openGL光照
aoxuestudy的专栏
02-06 642
openGL模拟光照：环境光、漫反射、镜面光
opengl学习笔记④——绕啊绕的行星系统（旋转，光照）
qq_38782152的博客
05-09 3553
月亮绕着地球转，地球绕着太阳转。多层旋转关系在opengl里是个啥玩意？让我们来看一看。在opengl中，我们的各种操作会最终产生一个矩阵，矩阵与代表顶点的向量相乘得到最终的顶点信息。不过有趣的是，如果我们依次写下操作1，2，对应矩阵A,B，如果顶点的列向量是V，则变换的结果V'=ABV。可以看到的是，后定义的B操作先应用在了V上。这是因为opengl内的矩阵是右乘的（具体问度娘）。我不是很喜欢这...
opengl学习笔记Ⅴ——磨人的轨迹球真可爱
qq_38782152的博客
05-23 1851
这回我们继续优化交互。使用轨迹球来使得模型转得更加人性化。涉及的问题有点多，我分点来讲。一、多大的范围是球上的点？这里我们需要先讲一下投影矩阵那些事。参考文章：https://www.cnblogs.com/graphics/archive/2012/07/25/2582119.html如上图，我们在投影体内有一个点P，我们需要将它映射到前裁剪面得到P‘，再把裁剪平面缩放为屏幕大小，我们就可以得到...
Opengl复习笔记（一）——顶点着色器、片段着色器（内含代码）
小石子的博客
12-25 7898
好的，又是因为要面试，这个面试需要复习opengl、图像算法、机器学习、算法题。所以会写相应的系列文章。。。 opengl从入门到菜鸡工程师之路基础架构介绍顶点着色器、片段着色器顶点输入顶点着色器片段着色器把上面过程串起来数据输入纹理的使用 基础架构介绍 首先opengl是一个做显示的的东西。首先对他的一个基本流程有一个初步的概念。 常见的工作流程： 创建一个对象，用一个id保存他的应用 将对象绑定至上下文的目标位置（比如窗口对象） 设置绑定的一些选项 进行一系列的操作 将目标位置对象id设置回0，解绑这
OSG学习笔记20——光照和材质的设置（正确绘制出想要的颜色）
吃货敲代码
03-25 9413
本来一开始学习OSG和Opengl的时候，因为用不太到关于颜色渲染之类的内容，关注的比较多的都是如何与场景进行交互。现在突然想给场景添加一个地面，发现不能得到正确的结果，并且加载进来的模型也会随着地面颜色的改变而呈现不同的颜色。
oepngl学习笔记——让p(l)y变得cool~（光照）
qq_38782152的博客
05-09 1184
上一讲我们大致讲了如何绘制ply。但是这还不够，你得到的东西看起来就像是一个颜色块。这是因为这个世界没有光，我们要加上光照的效果。为此，我们在Init函数里这样设置glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);这样我们开启了光照功能，并启动了light0，你可以依葫芦画瓢的启动light1,2,3,4……不过，要注意的是，在opengl管线编程，也就是像我们...
OpenGL的光照详解
04-28
OpenGL的光照详解,属于图形学的范畴。
OpenGL光照测试（源代码+演示程序）
08-07
此资源是我写的博客中的源代码，需要的同学可以下载。 --------------------------------------------------- 欢迎访问我的博客： http://blog.csdn.net/gamesdev --------------------------------------------------- 有关OpenGL光照测试的博客： http://blog.csdn.net/gamesdev/article/details/9796715 http://blog.csdn.net/gamesdev/article/details/9766713 --------------------------------------------------- 之前从来都没有涉及光照的内容，心想只要能通过常规的方法渲染出几何体甚至是模型就可以了，然而没有光照的日子注定是苦涩的，因为仅凭几何体和模型的颜色无法达到真是渲染的效果，在实际中有各种各样的光影响着我们的视觉效果，而OpenGL能够为我们还原现实生活中的光照现象。所以，我还是下决心研究OpenGL的光照了！
OpenGL光照
计算机技术交流
03-19 1046
1. OpenGL光照分类 OpenGL光由自发光（Emitted Light）、环境光（Ambient Light）、漫反射光（Diffuse Light）和高光（Specular Light)组成 自发光（Emitted Light）：由物体自身发出并且不受任何光源影响。如果物体本身不发光，则无此属性。 环境光（Ambient Light）：那些在环境中进行了充分散射，而无法
OpenGL-光照
weixin_45054115的博客
08-30 2999
OpenGL 光照
OpenGL - 光照
wyg1997
11-08 560
这个是书上的代码，就是一个茶壶加上光照。以后学深了再补。运行效果： 代码如下：#include<cstdio> #include<GL\glut.h> #include<Windows.h> #include<algorithm> using namespace std; void init() { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0
opengl笔记—— glMultMatrixf() 区别 glLoadMatrixf()
最新发布
06-06
在OpenGL中，glMultMatrixf()和glLoadMatrixf()都是用来设置矩阵的函数，但它们有一些区别。 glLoadMatrixf()函数用于设置当前矩阵为指定矩阵，这意味着当前矩阵将完全替换为指定矩阵。例如，如果我们想在模型视图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大鱼BIGFISH

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值