OpenGL光源之 多光源

最新推荐文章于 2023-09-29 19:46:25 发布
最新推荐文章于 2023-09-29 19:46:25 发布
阅读量418 收藏 1
点赞数 2
分类专栏： OpenGL学习 文章标签： OpenGL 计算机图形学 着色器 OpenGL入门 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51563654/article/details/130512917
版权

引言

 不多讲解，直接上代码，代码上都有注释，草履虫都能看懂。
 本文的程序来自于OpenGL中文教程，这一节内容我调试了好久，一下午才把Bug修复。
 总结，当你拿到别人的OpenGL代码时，首先你要看主程序中的外部依赖库和一些头文件你是否具有，然后你需要对着色器的文件地址进行修改，然后就是对资源如图片的文件地址进行修改。
 教程原文中的代码是具有Bug的，第一个Bug就是纹理过滤方式的设置，纹理过滤方式不能将放大纹理设置为多级渐进纹理GL_NEAREST_MIPMAP_NEAREST，不然你使用glGetError会报错的。第二个Bug是经典Bug,就是定义矩阵变量时未初始化，即 glm::mat4 model; 这样，教程中所有矩阵定义都没有初始化，这样矩阵的值是未知的，会导致你什么都看不到。记住，只要声明矩阵就要 glm::mat4 model = glm::mat4(1.of); 这样去初始化矩阵。只要是教程中的代码，都需要ctrl+F在编辑器中查找glm::mat4，然后对每一处声明进行修改。
 运行效果：
在这里插入图片描述
在这里插入图片描述)

代码

 注释都在代码中，保姆级注释。

顶点着色器

 光源的顶点着色器：

#version 330 core
// 传入局部坐标下的顶点坐标
layout( location = 0 ) in vec3 position;

// 传入变换矩阵
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
	// 光源的顶点着色器只需要计算出光源顶点在裁剪空间中的位置即可
	gl_Position = projection * view * model * vec4(position, 1.0f);
}

 物体的顶点着色器：

// OpenGL版本的声明
#version 330 core

// 顶点数组输入的 位置、法向量、纹理坐标（局部坐标系下）
layout( location = 0 ) in vec3 position;
layout( location = 1 ) in vec3 normal;
layout( location = 2 ) in vec2 texCoords;

// 内存中传入的 模型、观察、投影
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

// 输出顶点的 位置、法向量、纹理坐标（世界坐标下）
out vec3 FragPos;
out vec3 Normal;
out vec2 TexCoords;

void main()
{
	// 计算顶点坐标（观察坐标系下）
	gl_Position = projection * view * model * vec4(position, 1.0f);

	// 计算世界坐标系下的顶点坐标
	FragPos = vec3(model * vec4(position, 1.0f));
	// 计算世界坐标系下的顶点法向量
	// 即对模型矩阵取逆转置 乘以 局部坐标系下的法向量 = 世界坐标系下法向量
	// 此处也可以使用正规矩阵对法向量进行变换
	Normal = mat3(transpose(inverse(model))) * normal;


 	// 纹理坐标无需转换
	TexCoords = texCoords; 
}

片段着色器

 光源的片段着色器：

#version 330 core
out vec4 color;

void main()
{
    // 光源的片段着色器只需要将其显示为一个很亮的物体即可
    color = vec4(1.0f); //设置四维向量的所有元素为 1.0f
}

 物体的片段着色器：

// OpenGL版本声明
#version 330 core

// 材质结构体
struct Material {
    // 漫反射采样器
    sampler2D diffuse;
    // 镜面反射采样器
    sampler2D specular;
    // 高光的发光值
    float shininess;
}; 

// 平行光结构体
struct DirLight {
    // 平行光的方向
    vec3 direction;
    // 环境光颜色值
    vec3 ambient;
    // 漫反射光颜色值
    vec3 diffuse;
    // 镜面反射光颜色值
    vec3 specular;
};

// 点光源结构体
struct PointLight {
    // 点光源的位置
    vec3 position;
    // 点光源的衰减参数（平行光无限远，只有平行光不衰减）
    float constant;
    float linear;
    float quadratic;
    // 颜色值
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

// 聚光结构体
struct SpotLight {
    // 聚光的位置
    vec3 position;
    // 聚光的方向
    vec3 direction;
    // 聚光的内圆锥角的余弦值
    float cutOff;
    // 聚光的外圆锥角的余弦值
    float outerCutOff;
  
    // 聚光的衰减参数
    float constant;
    float linear;
    float quadratic;
  
    // 颜色值
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;       
};

// 使用预处理器指令定义点光源的数目
#define NR_POINT_LIGHTS 4

// 来自vertexShader的输入：位置、向量、纹理坐标
in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;

// 输出颜色
out vec4 color;

// 来自程序(内存)的输入：观察者位置、平行光光源、点光源、聚光光源、对象材质
uniform vec3 viewPos;
uniform DirLight dirLight;
uniform PointLight pointLights[NR_POINT_LIGHTS];
uniform SpotLight spotLight;
uniform Material material;

// 方法的声明（点光源和聚光参考距离，需要fragPos参数）
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir);
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir);

void main()
{    
    // 标准化法向量
    vec3 norm = normalize(Normal);
    // 计算观察方向（由片段位置指向观察者位置）
    vec3 viewDir = normalize(viewPos - FragPos);
    
    // 计算平行光光照得到的颜色
    vec3 result = CalcDirLight(dirLight, norm, viewDir);
    // 叠加各个点光源光照得到的颜色
    for(int i = 0; i < NR_POINT_LIGHTS; i++)
        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);    
    // 叠加聚光的颜色值
    result += CalcSpotLight(spotLight, norm, FragPos, viewDir);    
    
    // 输出最终计算出的颜色值
    color = vec4(result, 1.0);
}

// 平行光计算光照颜色
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
{
    // 标准化并逆向平行光（得到从片段指向光源的方向向量）
    vec3 lightDir = normalize(-light.direction);

    // 根据法向量和方向向量计算漫反射系数（最小值为0，负面或垂直）
    float diff = max(dot(normal, lightDir), 0.0);
    // 根据光入射方向和法向量计算光反射方向
    vec3 reflectDir = reflect(-lightDir, normal);
    // 计算镜面反射系数pow(观察者方向和反射方向的夹角余弦，发光值)
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);

    // 计算环境光、漫反射光、镜面反射光（颜色值 = 光对应的颜色值  * 对应参数值 * 采样器采样颜色值）
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));

    // 返回 三种光的颜色值之和
    return (ambient + diffuse + specular);
}

// 点光源计算光照颜色（多了一个参数fragPos表示片段的位置）
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    // 光源方向向量需要自己计算 = 标准化（光源位置 - 片段位置）
    vec3 lightDir = normalize(light.position - fragPos);

    // 计算diff漫反射和spec镜面反射的参数
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);

    // 计算光源和片段之间的距离
    float distance = length(light.position - fragPos);
    // 计算衰减系数 = 1 / （光源的衰减常数 + 光源的衰减一次系数 * 距离 + 光源的衰减二次系数 * 距离的平方）
    float attenuation = 1.0f / (light.constant + light.linear * distance + light.quadratic * (distance * distance));    

    // 计算环境光、漫反射光、镜面反射光的颜色值
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));

    // 使用衰减系数对所有光进行衰减
    ambient *= attenuation;
    diffuse *= attenuation;
    specular *= attenuation;

    // 返回所有光颜色值的和
    return (ambient + diffuse + specular);
}

// 聚光计算光照颜色
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    // 同上计算 光照方向、光照系数、距离、衰减系数
    vec3 lightDir = normalize(light.position - fragPos);
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    float distance = length(light.position - fragPos);
    float attenuation = 1.0f / (light.constant + light.linear * distance + light.quadratic * (distance * distance));    

    // 计算 光照方向lightDir 与 聚光轴方向light.direction 间夹角的余弦值
    float theta = dot(lightDir, normalize(-light.direction)); 
    // 计算 内圆锥余弦值 - 外圆锥余弦值
    float epsilon = light.cutOff - light.outerCutOff;
    // 计算 圆锥光亮值 = （光照方向和聚光轴方向夹角余弦值 - 外圆锥的余弦值）/ 两圆锥余弦差值 
    float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
    
    // 计算各种光颜色值
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
       
    // 使用衰减系数和锥形光亮值衰减各种光的颜色值
    ambient *= attenuation * intensity;
    diffuse *= attenuation * intensity;
    specular *= attenuation * intensity;

    // 返回各种光颜色值之和
    return (ambient + diffuse + specular);
}

主程序

#include <iostream>
#include <cmath>

// GLEW
#define GLEW_STATIC
#include <GL/glew.h>

// GLFW
#include <GLFW/glfw3.h>

// 资源加载库
#include <SOIL.h>
// GLM 数学库
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

// 其他头文件
#include "Shader.h"
#include "Camera.h"

// 函数声明（按键、鼠标移动、鼠标滚轮回调函数 和 事件处理函数）
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void do_movement();

// 定义窗口的大小
const GLuint WIDTH = 800, HEIGHT = 600;

// 构造相机 和 鼠标在窗口中的初始位置
Camera  camera(glm::vec3(0.0f, 0.0f, 3.0f));
GLfloat lastX = WIDTH / 2.0;
GLfloat lastY = HEIGHT / 2.0;
// 按键记录数组（记录是否处于按下状态）
bool    keys[1024];

// 定义光源位置
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);

// 帧相差时间的记录
GLfloat deltaTime = 0.0f;	// Time between current frame and last frame
GLfloat lastFrame = 0.0f;  	// Time of last frame

// MAIN函数，从这里我们启动应用程序并运行游戏循环
int main()
{
    // 初始化 GLFW
    glfwInit();
    // 设置GLFW使用OpenGL3.3版本和核心模式，设置窗口大小不可改变
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    // 创建GLFW窗口并设置为线程的主上下文
    GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
    glfwMakeContextCurrent(window);

    // 对GLFW窗口注册回调函数
    glfwSetKeyCallback(window, key_callback);
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);

    // 设置GLFW的模式为：鼠标不可见
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    // 设置glew为更现代的
    glewExperimental = GL_TRUE;
    // 初始化 GLEW 
    glewInit();

    // 定义视口的位置（视口的左下角相对窗口左下角的位置）和大小
    glViewport(0, 0, WIDTH, HEIGHT);

    // 开启OpenGL的深度测试功能
    glEnable(GL_DEPTH_TEST);

    // 编译着色器程序
    Shader lightingShader("C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Shader\\vertexShader.txt", "C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Shader\\fragmentShader.txt");
    Shader lampShader("C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Shader\\lightVertexShader.txt", "C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Shader\\lightFragmentShader.txt");

    // 顶点数据
    GLfloat vertices[] = {
        // 位置               // 法向量            // 纹理坐标
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  0.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,

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

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

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

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

        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f
    };
    // 不同箱子的位置
    glm::vec3 cubePositions[] = {
        glm::vec3(0.0f,  0.0f,  0.0f),
        glm::vec3(2.0f,  5.0f, -15.0f),
        glm::vec3(-1.5f, -2.2f, -2.5f),
        glm::vec3(-3.8f, -2.0f, -12.3f),
        glm::vec3(2.4f, -0.4f, -3.5f),
        glm::vec3(-1.7f,  3.0f, -7.5f),
        glm::vec3(1.3f, -2.0f, -2.5f),
        glm::vec3(1.5f,  2.0f, -2.5f),
        glm::vec3(1.5f,  0.2f, -1.5f),
        glm::vec3(-1.3f,  1.0f, -1.5f)
    };
    // 不同光源的位置
    glm::vec3 pointLightPositions[] = {
        glm::vec3(0.7f,  0.2f,  2.0f),
        glm::vec3(2.3f, -3.3f, -4.0f),
        glm::vec3(-4.0f,  2.0f, -12.0f),
        glm::vec3(0.0f,  0.0f, -3.0f)
    };

    // 设置被渲染物体的缓存数据
    GLuint VBO, containerVAO;
    // 申请显存空间（VBO可以通用，对于光和非光物体，VAO不可通用）
    glGenVertexArrays(1, &containerVAO);
    glGenBuffers(1, &VBO);
    // 绑定缓冲区
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // 将绑定GL_ARRAY_BUFFER中的内容 传到 显存中
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // 绑定顶点缓冲数组VAO
    glBindVertexArray(containerVAO);
    // 设置被旋转物体的数据解析方式
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);   // 启用输入位置0
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
    glEnableVertexAttribArray(2);
    glBindVertexArray(0);

    // 设置光源的VAO
    GLuint lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);
    // VBO是物体的顶点数据，光源可以使用，因此VBO可通用
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // VBO已经传输给内存，因此不需再传输。设置数据解析方式（仅需顶点位置）
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Note that we skip over the other data in our buffer object (we don't need the normals/textures, only positions).
    glEnableVertexAttribArray(0);
    glBindVertexArray(0);

    // 加载：漫反射、镜面反射、放射光贴图
    GLuint diffuseMap, specularMap, emissionMap;
    glGenTextures(1, &diffuseMap);
    glGenTextures(1, &specularMap);
    glGenTextures(1, &emissionMap);
    int width, height;
    unsigned char* image;
    // 加载纹理
    image = SOIL_load_image("C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Resource\\container2.png", &width, &height, 0, SOIL_LOAD_RGB);
    // 绑定纹理贴图到对应纹理上
    glBindTexture(GL_TEXTURE_2D, diffuseMap);
    // 设置纹理贴图的数据
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    // 生成纹理贴图的多级渐进纹理
    glGenerateMipmap(GL_TEXTURE_2D);
    // 释放贴图内存
    SOIL_free_image_data(image);
    // 设置纹理的环绕方式和过滤方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    // 同上
    image = SOIL_load_image("C:\\Users\\32156\\source\\repos\\LearnOpenGL\\Resource\\container2_specular.png", &width, &height, 0, SOIL_LOAD_RGB);
    glBindTexture(GL_TEXTURE_2D, specularMap);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);
    SOIL_free_image_data(image);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);

    // 为 光照物体的着色器 中 材质的纹理采样器 分配纹理单元（由于不变所以写在循环外） 
    lightingShader.Use();
    glUniform1i(glGetUniformLocation(lightingShader.Program, "material.diffuse"), 0);
    glUniform1i(glGetUniformLocation(lightingShader.Program, "material.specular"), 1);

    // Game loop
    while (!glfwWindowShouldClose(window))
    {
        // 计算帧相差时间
        GLfloat currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // 窗口事件检测并处理
        glfwPollEvents();
        do_movement();

        // 清空屏幕和深度缓存
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 使用物体的着色器
        lightingShader.Use();
        // 设置着色器中观察者的位置为相机位置
        GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos");
        glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
        // 设置高光的发光值为32
        glUniform1f(glGetUniformLocation(lightingShader.Program, "material.shininess"), 32.0f);
        
        // 设置平行光的方向、材质本体颜色-环境光、材质本体颜色-漫反射光、材质本体颜色-高光
        glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.direction"), -0.2f, -1.0f, -0.3f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.ambient"), 0.05f, 0.05f, 0.05f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.diffuse"), 0.4f, 0.4f, 0.4f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.specular"), 0.5f, 0.5f, 0.5f);
        // 设置第一个点光源的位置、材质本体颜色-环境光、材质本体颜色-漫反射光、材质本体颜色-高光、距离衰减系数-常数项、距离衰减系数- 一次项、距离衰减系数-二次项
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].linear"), 0.09);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].quadratic"), 0.032);
        // 设置第二个点光源
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].linear"), 0.09);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].quadratic"), 0.032);
        // 设置第三个点光源
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].ambient"), 0.05f, 0.05f, 0.05f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].linear"), 0.09);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].quadratic"), 0.032);
        // 设置第四个点光源
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].position"), pointLightPositions[3].x, pointLightPositions[3].y, pointLightPositions[3].z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].ambient"), 0.05f, 0.05f, 0.05f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].linear"), 0.09);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].quadratic"), 0.032);
        // 设置聚光的位置、轴向、材质本体颜色-环境光、材质本体颜色-漫反射光、材质本体颜色-高光、距离衰减系数-常数项、距离衰减系数- 一次项、距离衰减系数-二次项、内圆锥夹角余弦、外圆锥夹角余弦
        glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.position"), camera.Position.x, camera.Position.y, camera.Position.z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.direction"), camera.Front.x, camera.Front.y, camera.Front.z);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.ambient"), 0.0f, 0.0f, 0.0f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.diffuse"), 1.0f, 1.0f, 1.0f);
        glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.linear"), 0.09);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.quadratic"), 0.032);
        glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.cutOff"), glm::cos(glm::radians(12.5f)));
        glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.outerCutOff"), glm::cos(glm::radians(15.0f)));

        // 创建观察矩阵（创建矩阵就要初始化）
        glm::mat4 view = glm::mat4(1.0f);
        // 通过摄像机信息获得观察矩阵
        view = camera.GetViewMatrix();
        // 根据摄像机信息获得投影矩阵
        glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
        // 获得 模型、观察、投影矩阵在着色器中的位置
        GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model");
        GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view");
        GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection");
        // 先设置观察矩阵和投影矩阵（因为模型矩阵跟每个物体有关，需要循环，而渲染一个个物体也要循环，所有干脆后面一起写在循环里）
        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

        // 激活纹理单元0，绑定漫反射贴图
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, diffuseMap);
        // 激活纹理单元0，绑定镜面反射贴图
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, specularMap);

        // 循环渲染所有物体
        glm::mat4 model;
        // 绑定VAO
        glBindVertexArray(containerVAO);
        for (GLuint i = 0; i < 10; i++)
        {
            // 根据每个物体的位置计算模型矩阵
            model = glm::mat4(1.0f);
            model = glm::translate(model, cubePositions[i]);
            // 随机设置物体的旋转角度和旋转分量，并据此计算模型矩阵（计算顺序：位移->旋转->缩放）
            GLfloat angle = 20.0f * i;
            model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f));
            // 传入物体的模型矩阵
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            // 绘制物体
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }
        glBindVertexArray(0);


        // 使用光源的着色器
        lampShader.Use();
        // 获得光源着色器中变换矩阵的位置
        modelLoc = glGetUniformLocation(lampShader.Program, "model");
        viewLoc = glGetUniformLocation(lampShader.Program, "view");
        projLoc = glGetUniformLocation(lampShader.Program, "projection");
        // 观察矩阵和投影矩阵是由摄像机信息决定的，因此光源也使用上文计算出的同样的观察矩阵和投影矩阵
        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

        // 绑定光源的VAO（仅包含立方体顶点位置信息）
        glBindVertexArray(lightVAO);
        for (GLuint i = 0; i < 4; i++)
        {
            // 只显示点光源，计算点光源的模型矩阵（根据点光源位置和缩放信息）
            model = glm::mat4(1.0f);
            model = glm::translate(model, pointLightPositions[i]);
            model = glm::scale(model, glm::vec3(0.2f)); 
            // 传入模型矩阵
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            // 绘制点光源
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }
        glBindVertexArray(0);

        // 交换前后缓冲区
        glfwSwapBuffers(window);

        // 检测OpenGL是否有错误信息（返回0表示正常，非0异常则打印异常编号）
        GLint err = glGetError();
        if (err)
        {
            std::cout << err << std::endl;
        }
    }

    // 如果GLFW窗口关闭则释放glfw相应存储空间
    glfwTerminate();
    return 0;
}

// 按键回调函数（当按下某个键时就会回调，将其在keys数组中记录为true表示已按下）
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)// ESC键关闭窗口结束程序
        glfwSetWindowShouldClose(window, GL_TRUE);
    if (key >= 0 && key < 1024)// 这个区间表示常用按键
    {
        if (action == GLFW_PRESS)
            keys[key] = true;
        else if (action == GLFW_RELEASE) // 如果松开了某个键，则设置其为flase表示未按下
            keys[key] = false;
    }
}

void do_movement()
{
    // 检测是否按下WASD，是则移动摄像机
    if (keys[GLFW_KEY_W])
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (keys[GLFW_KEY_S])
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (keys[GLFW_KEY_A])
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (keys[GLFW_KEY_D])
        camera.ProcessKeyboard(RIGHT, deltaTime);
}

// 如果第一次进入窗口，鼠标位置是未知的，我们需要将其重置为上文中的默认位置
bool firstMouse = true;
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
    if (firstMouse)// 如果第一次进入窗口
    {
        // 设置鼠标位置为我们定义的默认位置
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    // 移动鼠标时 计算与上次记录的鼠标位置的差距
    GLfloat xoffset = xpos - lastX;
    GLfloat yoffset = lastY - ypos; 

    // 更新鼠标位置
    lastX = xpos;
    lastY = ypos;

    // 根据鼠标移动调用摄像机方法，移动摄像机视角
    camera.ProcessMouseMovement(xoffset, yoffset);
}

// 当鼠标滚动时，调用摄像机方法传入鼠标滚动的差距值，摄像机会调整视野fov的大小以放大和缩小
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(yoffset);
}
OpenGL多重照明-实现多光源
CodeMaven的博客
08-25 181
在计算机图形学中，照明是一个非常重要的环节，它可以让场景更加逼真，也是提高渲染质量的关键因素。在本文中，我们将介绍如何使用OpenGL来实现多光源的照明效果，并提供相应的源代码。综上所述，实现多光源照明效果需要定义多个光源，并计算各个光源对物体表面的影响，最终将各个光源的影响值相加得到总的照明效果。OpenGL提供了丰富的API来实现多光源照明，开发者只需合理地使用这些API即可实现逼真的场景呈现效果。最终的照明效果可以应用到物体表面的材质属性中，以实现多光源照明效果。OpenGL多重照明-实现多光源。
opengl-多光源
笃笃前行的专栏
12-24 682
opengl-多光源多光源定向光点光源合并结果 多光源 为了在场景中使用多个光源，我们希望将光照计算封装到GLSL函数中。这样做的原因是，每一种光源都需要一种不同的计算方法，而一旦我们想对多个光源进行光照计算时，代码很快就会变得非常复杂。如果我们只在main函数中进行所有的这些计算，代码很快就会变得难以理解。 当我们在场景中使用多个光源时，通常使用以下方法：我们需要有一个单独的颜色向量代表片段的输...
OpenGL学习笔记一之光照篇六 多光源
飞飞飞的博客
05-05 751
转载自https://learnopengl-cn.github.io/02%20Lighting/06%20Multiple%20lights/ 我们在前面的教程中已经学习了许多关于OpenGL中光照的知识，其中包括冯氏着色(Phong Shading)、材质(Material)、光照贴图(Lighting Map)以及不同种类的投光物(Light Caster)。在这一节中，我们将结合之前...
LearnOpenGL笔记-多光源
qq_46256596的博客
02-02 241
这里我们想要使用多个点光源，在GLSL中使用了预处理指令来定义了我们场景中点光源的数量。所以我们会用不同的函数来对不同的光照类型进行计算，并在main函数中进行结合输出。GLSL函数语法与C很像，需要注意的几点是若函数不是在main函数之前声明的，则必须要在代码顶部声明一个原型。在main函数后面实现CalcDirLight函数（若在main函数之前，则可不用声明原型，与C类似）。最后，我们使用了多个光源立方体，因此，我们需要对不同的光源立方体进行模型变换，变换到不同的位置上去。
OpenGL学习笔记（五）-投光物-多光源
Catog的博客
04-11 527
参考网址：LearnOpenGL 中文版 哔哩哔哩教程 2.5 投光物 2.5.1 平行光 1、当一个光源处于很远的地方时，来自光源的每条光线就会近似于互相平行，例如太阳。不论物体和/或者观察者的位置，看起来好像所有的光都来自于同一个方向。当假设光源处于无限远处的模型时，它就被称为定向光。 2、通过定义光线方向向量即可模拟一个定向光。 struct LightDirect { vec3 lightDir; vec3 ambient; vec3 diffuse; vec3
Opengl之多光源
最新发布
qq_44632658的博客
09-29 212
GLSL中的函数和C函数很相似，，如果函数不是在main函数之前声明的，我们还必须在代码文件顶部声明一个原型。我们对每个光照类型都创建一个不同的函数：定向光、点光源和聚光当我们在场景中，通常使用以下方法：我们需要有一个单独的颜色向量代表片段的输出颜色。对于每一个光源，它对片段的贡献颜色将会加到片段的输出颜色向量上。所以场景中的每个光源都会计算它们各自对片段的影响，并结合为一个最终的输出颜色。实际的代码对每一种实现都可能不同，但大体的结构都是差不多的。
opengl光源和模型.rar_OPENGL 视点_opengl_opengl 光源_光源_开源 UML
09-20
在这个"opengl光源和模型.rar"压缩包中，重点讲述了OpenGL中的光源和视点操作，这对于创建逼真的3D场景至关重要。 首先，我们要理解OpenGL中的光源概念。在3D图形中，光源决定了物体表面的亮度和色彩，它分为多种...
OpenGL光源
牵LV小猪精的博客
04-26 1222
按照之前简化版点光源生成的 平行光
opengl.rar_OPENGL光照_opengl_opengl 光源_opengl 光照_opengl光照材质
09-19
在本压缩包中，我们关注的是如何利用OpenGL实现光照效果，包括光源的创建、激活、明暗处理方式的设定以及物体材质的定义。 首先，理解OpenGL中的光照模型是至关重要的。OpenGL提供了多种光照模型，如Phong模型，...
QT Opengl 光源 图形放大综合
04-08
在项目中，开发者可能创建了一个或多个光源，并通过OpenGL的函数如`glLightfv()`来调整光源属性，以实现动态的光照变化。 接着，图形放大缩小功能是通过改变视口大小或者投影矩阵实现的。在OpenGL中，视口定义了...
OpenGL光源参数例程.rar
04-05
这个"OpenGL光源参数例程.rar"文件包含的是一份易语言编写的源代码，旨在帮助开发者理解和掌握OpenGL中的光源参数设置。 在OpenGL中，光源参数是控制场景光照效果的关键元素。光源不仅包括位置、颜色，还有其他诸多...
OpenGL-- Shader 颜色 光照 5 多光源 基础
06-02
OpenGL-- Shader 颜色 光照 5 多光源 基础 VS2015 http://blog.youkuaiyun.com/yulinxx/article/details/72838217
【OpenGL】笔记十五、多光源
ycrsw的博客
05-22 338
1. 流程 介绍完了几种光源，现在我们要综合一下，我们将模拟一个类似太阳的定向光(Directional Light)光源，四个分散在场景中的点光源(Point Light)，以及一个手电筒(Flashlight)。 但是三种光源都写一遍有些杂乱，分开写着色器的话又有些浪费，怎么办呢？GLSL里面也有函数封装，我们把三种光源的属性分别定义结构体，然后传入函数计算，最后相加就行： #version 330 core struct Material { sampler2D diffuse; sa
OpenGL光照篇--多光源--14
weixin_41155760的博客
05-09 307
参考：多光源 整合多种光源类型在一个场景。 注：设置值的时候检查字符串和shader里的字符串是否对应。 如： cubeShader.setFloat("spotLight.outerCutoff", glm::cos(glm::radians(10.0f))); 多种光源需要在shader里计算所有类型的光照，叠加。 程序代码： //顺序不能错 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <stb_im
OpenGL之——多光源
衣带渐宽人憔悴
02-02 525
 竖直向上的平行光，四个点光源，还有与摄像头方向一致的手电筒光源  主要代码： #include &lt;iostream&gt; #include &lt;glad/glad.h&gt; #include &lt;GLFW/glfw3.h&gt; #define STB_IMAGE_IMPLEMENTATION #include &lt;stb_image.h&gt; #includ...
OpenGL光线六 opengl多光源 MultipleLights
yan17iiiiii的博客
04-01 273
一、定义短多个光源 //平行光 LightDirectional lightD(glm::vec3(10.0f, 10.0f, -5.0f), glm::vec3(glm::radians(90.0f), glm::radians(0.0f), 0)); //点光源 LightPoint lightP0(glm::vec3(1.0f, .0f, .0f), glm::vec3(glm::radia...
OpenGL-- Shader 颜色 光照 5 多光源
...
06-02 1613
OGLMultipleLights-OpenGL-- Shader 颜色 光照 5 多光源
LearnOpenGL-光照-6.多光源
qq_34060370的博客
03-11 524
此节目的综合2.5投光物，在此节实现一个场景使用多个光源，物体根据不同光源而叠加颜色。熟悉多光源如何计算物体颜色熟悉用glsl函数。
openGL绘制多光源球
柠萌味
02-11 1006
#include "stdafx.h"#include&lt;windows.h&gt;#include "gl.h"#include "glut.h"void RenderScene(void){ glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glPushMatrix(); glTranslatef(-3.0f, -3.0f, 3.0f);/...
易语言实现OpenGL光源参数设置教程
标题和描述中提到的“OpenGL光源参数例程”指的是一个包含示例代码的压缩包文件，该文件用于展示如何在使用OpenGL编程时设置和调整光源参数。OpenGL是一个开源的跨语言、跨平台的应用程序编程接口（API），它被用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

仰望—星空

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

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

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

打赏作者

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

抵扣说明：

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

余额充值