3.2 基础光照

最新推荐文章于 2023-10-21 00:00:29 发布
最新推荐文章于 2023-10-21 00:00:29 发布
阅读量240 收藏
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NelsonCheung/article/details/109409913
版权

基础光照

现实世界的光照是极其复杂的，而且会受到诸多因素的影响，这是我们有限的计算能力所无法模拟的。因此OpenGL的光照使用的是简化的模型。

其中一个模型是Phong光照模型，其主要有三个分量组成，环境(ambient)、漫反射(diffuse)和镜面光照(specular)。

环境光照

我们使用一个很小的常量（光照）颜色，添加到物体片段的最终颜色中，这样子的话即便场景中没有直接的光源也能看起来存在有一些发散的光。

把环境光照添加到场景里非常简单。我们用光的颜色乘以一个很小的常量环境因子，再乘以物体的颜色，然后将最终结果作为片段的颜色。

漫反射光照

漫反射光照使物体上与光线方向越接近的片段能从光源处获得更多的亮度。

镜面反射

我们通过反射法向量周围光的方向来计算反射向量。然后我们计算反射向量和视线方向的角度差，如果夹角越小，那么镜面光的影响就会越大。它的作用效果就是，当我们去看光被物体所反射的那个方向的时候，我们会看到一个高光。

code

环境光照

#include "../env/glm/glm.hpp"
#include "../env/glm/gtc/matrix_transform.hpp"
#include "../env/glm/gtc/type_ptr.hpp"
#include <iostream>

#define STB_IMAGE_IMPLEMENTATION
#include "../env/std_image.h"
#include "../env/glad.h"
#include "../env/glfw3.h"
#include <fstream>
#include "../tools/shader.h"
#include "../tools/camera.h"

#define WIDTH 800
#define HEIGHT 600

GLFWwindow *initialize(int width, int height);

void framebuffer_size_callback(GLFWwindow *window, int width, int height);
void mouse_callback(GLFWwindow *window, double xpos, double ypos);
void scroll_callback(GLFWwindow *window, double xoffset, double yoffset);

void processInput(GLFWwindow *window);

Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f),
                       glm::vec3(0.0f, 0.0f, -1.0f),
                       glm::vec3(0.0f, 1.0f, 0.0f),
                       0.0f, 0.0f);

float cameraSpeed = 2.5f;
float lastTime;
float lastXPos;
float lastYPos;
bool firstMouse;
float fov = 45.0f;

int main()
{
    GLFWwindow *window = initialize(WIDTH, HEIGHT);

    float vertices[] = {
        -0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
        0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, 0.0f, 0.0f,

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

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

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

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

        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        -0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f};

    unsigned int myVBO;
    glGenBuffers(1, &myVBO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    GLuint objectVAO;
    glGenVertexArrays(1, &objectVAO);
    glBindVertexArray(objectVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    GLuint lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    glm::mat4 model, view, projection;
    Shader lampShader("1-vertex.glsl", "1-lamp-fragment.glsl");
    Shader lightShader("1-vertex.glsl", "2-fragment.glsl");

    lastTime = glfwGetTime();

    while (!glfwWindowShouldClose(window))
    {
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(1.2f, 1.0f, 2.0f));
        model = glm::scale(model, glm::vec3(0.2f));

        view = camera.lookAt();
        projection = glm::perspective(glm::radians(fov), 1.0f * WIDTH / HEIGHT, 0.1f, 100.0f);

        
        lampShader.use();
        lampShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lampShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lampShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glBindVertexArray(lightVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        

        model = glm::mat4(1.0f);
        lightShader.use();
        lightShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lightShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lightShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glm::vec3 lightColor = glm::vec3(1.0f, 1.0f, 1.0f);
        glm::vec3 objectColor = glm::vec3(1.0f, 0.5f, 0.31f);
        lightShader.setv3("lightColor", glm::value_ptr(lightColor));
        lightShader.setv3("objectColor", glm::value_ptr(objectColor));
        glBindVertexArray(objectVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        
        processInput(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    glfwTerminate();
    return 0;
}

void framebuffer_size_callback(GLFWwindow *window, int width, int height)
{
    glViewport(0, 0, width, height);
}

void processInput(GLFWwindow *window)
{
    float currentTime = glfwGetTime();
    float delta = currentTime - lastTime;
    lastTime = currentTime;
    float distance = cameraSpeed * delta;

    // 移动照相机位置
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, true);
    }
    else if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    {
        camera.move(CameraMovement::FORWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    {
        camera.move(CameraMovement::BACKWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    {
        camera.move(CameraMovement::LEFT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    {
        camera.move(CameraMovement::RIGHT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
    {
        camera.move(CameraMovement::DOWN, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
    {
        camera.move(CameraMovement::UP, distance);
    }
}

GLFWwindow *initialize(int width, int height)
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "2", nullptr, nullptr);
    if (!window)
    {
        exit(-1);
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        exit(-1);
    }

    glViewport(0, 0, width, height);

    glfwSetWindowSizeCallback(window, framebuffer_size_callback);

    // 光标初始位置
    lastXPos = 400;
    lastYPos = 300;
    firstMouse = true;
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glfwSetCursorPosCallback(window, mouse_callback);

    glfwSetScrollCallback(window, scroll_callback);

    return window;
}

void mouse_callback(GLFWwindow *window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastXPos = xpos;
        lastYPos = ypos;
        firstMouse = false;
    }

    float sensitivity = 0.05f;
    float xOffset = (xpos - lastXPos) * sensitivity;
    float yOffset = (lastYPos - ypos) * sensitivity;

    lastXPos = xpos;
    lastYPos = ypos;

    camera.rotate(xOffset, yOffset);
}

void scroll_callback(GLFWwindow *window, double xoffset, double yoffset)
{
    fov -= yoffset;
    if (fov <= 1.0f)
    {
        fov = 1.0f;
    }
    if (fov >= 45.0f)
    {
        fov = 45.0f;
    }
}

2-fragment.glsl

#version 330 core

uniform vec3 lightColor;
uniform vec3 objectColor;

out vec4 FragColor;

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

环境光照+漫反射光照

#include "../env/glm/glm.hpp"
#include "../env/glm/gtc/matrix_transform.hpp"
#include "../env/glm/gtc/type_ptr.hpp"
#include <iostream>

#define STB_IMAGE_IMPLEMENTATION
#include "../env/std_image.h"
#include "../env/glad.h"
#include "../env/glfw3.h"
#include <fstream>
#include "../tools/shader.h"
#include "../tools/camera.h"

#define WIDTH 800
#define HEIGHT 600

GLFWwindow *initialize(int width, int height);

void framebuffer_size_callback(GLFWwindow *window, int width, int height);
void mouse_callback(GLFWwindow *window, double xpos, double ypos);
void scroll_callback(GLFWwindow *window, double xoffset, double yoffset);

void processInput(GLFWwindow *window);

Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f),
                       glm::vec3(0.0f, 0.0f, -1.0f),
                       glm::vec3(0.0f, 1.0f, 0.0f),
                       0.0f, 0.0f);

float cameraSpeed = 2.5f;
float lastTime;
float lastXPos;
float lastYPos;
bool firstMouse;
float fov = 45.0f;

int main()
{
    GLFWwindow *window = initialize(WIDTH, HEIGHT);

    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 myVBO;
    glGenBuffers(1, &myVBO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    GLuint objectVAO;
    glGenVertexArrays(1, &objectVAO);
    glBindVertexArray(objectVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float)));
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);

    GLuint lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    glm::mat4 model, view, projection;
    Shader lampShader("2.1-vertex.glsl", "1-lamp-fragment.glsl");
    Shader lightShader("2.1-vertex.glsl", "2.1-fragment.glsl");

    lastTime = glfwGetTime();
    glEnable(GL_DEPTH_TEST);

    while (!glfwWindowShouldClose(window))
    {
        model = glm::mat4(1.0f);
        glm::vec3 lightPos = glm::vec3(1.2f, 1.0f, 2.0f);
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(0.2f));

        view = camera.lookAt();
        projection = glm::perspective(glm::radians(fov), 1.0f * WIDTH / HEIGHT, 0.1f, 100.0f);

        lampShader.use();
        lampShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lampShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lampShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glBindVertexArray(lightVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        model = glm::mat4(1.0f);
        lightShader.use();
        lightShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lightShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lightShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glm::vec3 lightColor = glm::vec3(1.0f, 1.0f, 1.0f);
        glm::vec3 objectColor = glm::vec3(1.0f, 0.5f, 0.31f);
        lightShader.setv3("lightColor", glm::value_ptr(lightColor));
        lightShader.setv3("objectColor", glm::value_ptr(objectColor));
        lightShader.setv3("lightPos", glm::value_ptr(lightPos));
        glBindVertexArray(objectVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        processInput(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    glfwTerminate();
    return 0;
}

void framebuffer_size_callback(GLFWwindow *window, int width, int height)
{
    glViewport(0, 0, width, height);
}

void processInput(GLFWwindow *window)
{
    float currentTime = glfwGetTime();
    float delta = currentTime - lastTime;
    lastTime = currentTime;
    float distance = cameraSpeed * delta;

    // 移动照相机位置
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, true);
    }
    else if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    {
        camera.move(CameraMovement::FORWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    {
        camera.move(CameraMovement::BACKWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    {
        camera.move(CameraMovement::LEFT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    {
        camera.move(CameraMovement::RIGHT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
    {
        camera.move(CameraMovement::DOWN, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
    {
        camera.move(CameraMovement::UP, distance);
    }
}

GLFWwindow *initialize(int width, int height)
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "2", nullptr, nullptr);
    if (!window)
    {
        exit(-1);
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        exit(-1);
    }

    glViewport(0, 0, width, height);

    glfwSetWindowSizeCallback(window, framebuffer_size_callback);

    // 光标初始位置
    lastXPos = 400;
    lastYPos = 300;
    firstMouse = true;
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glfwSetCursorPosCallback(window, mouse_callback);

    glfwSetScrollCallback(window, scroll_callback);

    return window;
}

void mouse_callback(GLFWwindow *window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastXPos = xpos;
        lastYPos = ypos;
        firstMouse = false;
    }

    float sensitivity = 0.05f;
    float xOffset = (xpos - lastXPos) * sensitivity;
    float yOffset = (lastYPos - ypos) * sensitivity;

    lastXPos = xpos;
    lastYPos = ypos;

    camera.rotate(xOffset, yOffset);
}

void scroll_callback(GLFWwindow *window, double xoffset, double yoffset)
{
    fov -= yoffset;
    if (fov <= 1.0f)
    {
        fov = 1.0f;
    }
    if (fov >= 45.0f)
    {
        fov = 45.0f;
    }
}

2.1-vertex.glsl

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

out vec3 Normal;
out vec3 fragPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    gl_Position = projection * view * model * vec4(aPos, 1.0f);
    fragPos = vec3(model * vec4(aPos, 1.0f));
    // 物体变换到世界坐标时，法向量也应当跟随着变换过去
    Normal = mat3(transpose(inverse(model))) * aNormal;
}

2-fragment.glsl

#version 330 core

in vec3 Normal;
in vec3 fragPos;

uniform vec3 lightColor;
uniform vec3 objectColor;
uniform vec3 lightPos;

out vec4 FragColor;

void main() {
    float ambientStrength = 0.1;

    vec3 lightDir = normalize(lightPos - fragPos);
    vec3 normal = normalize(Normal);
    float diffuseStrength = max(0.0f, dot(normal, lightDir));
    
    FragColor = vec4((ambientStrength + diffuseStrength)* lightColor * objectColor, 1.0f);
}

环境光照+漫反射光照+镜面反射光照

#include "../env/glm/glm.hpp"
#include "../env/glm/gtc/matrix_transform.hpp"
#include "../env/glm/gtc/type_ptr.hpp"
#include <iostream>

#define STB_IMAGE_IMPLEMENTATION
#include "../env/std_image.h"
#include "../env/glad.h"
#include "../env/glfw3.h"
#include <fstream>
#include "../tools/shader.h"
#include "../tools/camera.h"

#define WIDTH 800
#define HEIGHT 600

GLFWwindow *initialize(int width, int height);

void framebuffer_size_callback(GLFWwindow *window, int width, int height);
void mouse_callback(GLFWwindow *window, double xpos, double ypos);
void scroll_callback(GLFWwindow *window, double xoffset, double yoffset);

void processInput(GLFWwindow *window);

Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f),
                       glm::vec3(0.0f, 0.0f, -1.0f),
                       glm::vec3(0.0f, 1.0f, 0.0f),
                       0.0f, 0.0f);

float cameraSpeed = 2.5f;
float lastTime;
float lastXPos;
float lastYPos;
bool firstMouse;
float fov = 45.0f;

int main()
{
    GLFWwindow *window = initialize(WIDTH, HEIGHT);

    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 myVBO;
    glGenBuffers(1, &myVBO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    GLuint objectVAO;
    glGenVertexArrays(1, &objectVAO);
    glBindVertexArray(objectVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float)));
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);

    GLuint lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);
    glBindBuffer(GL_ARRAY_BUFFER, myVBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    glm::mat4 model, view, projection;
    Shader lampShader("2.2-vertex.glsl", "1-lamp-fragment.glsl");
    Shader lightShader("2.2-vertex.glsl", "2.2-fragment.glsl");

    lastTime = glfwGetTime();
    glEnable(GL_DEPTH_TEST);

    while (!glfwWindowShouldClose(window))
    {
        model = glm::mat4(1.0f);
        glm::vec3 lightPos = glm::vec3(1.2f, 1.0f, 2.0f);
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(0.2f));

        view = camera.lookAt();
        projection = glm::perspective(glm::radians(fov), 1.0f * WIDTH / HEIGHT, 0.1f, 100.0f);

        lampShader.use();
        lampShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lampShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lampShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glBindVertexArray(lightVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        model = glm::mat4(1.0f);
        lightShader.use();
        lightShader.setm4fv("model", GL_FALSE, glm::value_ptr(model));
        lightShader.setm4fv("view", GL_FALSE, glm::value_ptr(view));
        lightShader.setm4fv("projection", GL_FALSE, glm::value_ptr(projection));
        glm::vec3 lightColor = glm::vec3(1.0f, 1.0f, 1.0f);
        glm::vec3 objectColor = glm::vec3(1.0f, 0.5f, 0.31f);
        lightShader.setv3("lightColor", glm::value_ptr(lightColor));
        lightShader.setv3("objectColor", glm::value_ptr(objectColor));
        glm::vec3 cameraPos = camera.getPosition();
        lightShader.setv3("viewPos", glm::value_ptr(cameraPos));
        lightShader.setv3("lightPos", glm::value_ptr(lightPos));
        glBindVertexArray(objectVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        processInput(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    glfwTerminate();
    return 0;
}

void framebuffer_size_callback(GLFWwindow *window, int width, int height)
{
    glViewport(0, 0, width, height);
}

void processInput(GLFWwindow *window)
{
    float currentTime = glfwGetTime();
    float delta = currentTime - lastTime;
    lastTime = currentTime;
    float distance = cameraSpeed * delta;

    // 移动照相机位置
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, true);
    }
    else if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    {
        camera.move(CameraMovement::FORWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    {
        camera.move(CameraMovement::BACKWARD, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    {
        camera.move(CameraMovement::LEFT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    {
        camera.move(CameraMovement::RIGHT, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
    {
        camera.move(CameraMovement::DOWN, distance);
    }
    else if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
    {
        camera.move(CameraMovement::UP, distance);
    }
}

GLFWwindow *initialize(int width, int height)
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "2", nullptr, nullptr);
    if (!window)
    {
        exit(-1);
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        exit(-1);
    }

    glViewport(0, 0, width, height);

    glfwSetWindowSizeCallback(window, framebuffer_size_callback);

    // 光标初始位置
    lastXPos = 400;
    lastYPos = 300;
    firstMouse = true;
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glfwSetCursorPosCallback(window, mouse_callback);

    glfwSetScrollCallback(window, scroll_callback);

    return window;
}

void mouse_callback(GLFWwindow *window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastXPos = xpos;
        lastYPos = ypos;
        firstMouse = false;
    }

    float sensitivity = 0.05f;
    float xOffset = (xpos - lastXPos) * sensitivity;
    float yOffset = (lastYPos - ypos) * sensitivity;

    lastXPos = xpos;
    lastYPos = ypos;

    camera.rotate(xOffset, yOffset);
}

void scroll_callback(GLFWwindow *window, double xoffset, double yoffset)
{
    fov -= yoffset;
    if (fov <= 1.0f)
    {
        fov = 1.0f;
    }
    if (fov >= 45.0f)
    {
        fov = 45.0f;
    }
}

2.2-vertex.glsl

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

out vec3 Normal;
out vec3 fragPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    gl_Position = projection * view * model * vec4(aPos, 1.0f);
    fragPos = vec3(model * vec4(aPos, 1.0f));
    // 物体变换到世界坐标时，法向量也应当跟随着变换过去
    Normal = mat3(transpose(inverse(model))) * aNormal;
}

2.2-fragment.glsl

#version 330 core

in vec3 Normal;
in vec3 fragPos;

uniform vec3 lightColor;
uniform vec3 objectColor;
uniform vec3 lightPos;
uniform vec3 viewPos;

out vec4 FragColor;

void main() {
    float ambientStrength = 0.1;

    vec3 lightDir = normalize(lightPos - fragPos);
    vec3 normal = normalize(Normal);
    float diffuseStrength = max(0.0f, dot(normal, lightDir));
    
    vec3 viewDir = normalize(viewPos - fragPos);
    vec3 reflectDir = reflect(-lightDir, normal);
    float specularStrength = pow(max(0.0f, dot(viewDir, reflectDir)), 16) * 0.5;

    FragColor = vec4((ambientStrength + diffuseStrength + specularStrength)* lightColor * objectColor, 1.0f);
}
NelsonCheung
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基本光照
六天
09-11 503
Phong光照模型现实世界的光照是极其复杂的，而且会受到诸多因素的影响，这是我们有限的计算能力所无法模拟的，所以我们使用数学和物理工具来简化和描述现实世界的光照，使得最终呈现的效果尽可能的接近现实。其中，我们最常用的一种称为Phong(冯氏)光照模型。Phong光照模型使用环境光(ambient)，漫反射光(diffuse)，高光反射(specular)三个分量来描述一个被光照射的物体的光照颜色。
光照
chinawwj2003的专栏
02-18 635
<br />一、光照<br />  在OpenGL场景描述中可以包含多个光源，光源的各种属性设置使用函数：<br />  void glLight{if} (GLenum light, GLenum pname, TYPE param);<br /> void glLight{if}v (GLenum light, GLenum pname, TYPE *param);<br />指定。其中，参数light指定进行参数设置的光源，其取值可以是符号常量GL_LIGHT0，GL_LIGHT1，…，GL_LIGH
Learn OpenGL CN
04-07
OpenGL
OpenGL 图形库的使用（十二）—— 光照之基础光照
轻纱罗曼细柳腰--腰子
09-27 385
版本记录 版本号 时间 V1.0 2017.10.30 前言 OpenGL 图形库项目中一直也没用过，最近也想学着使用这个图形库，感觉还是很有意思，也就自然想着好好的总结一下，希望对大家能有所帮助。1. OpenGL 图形库使用（一） —— 概念基础2. OpenGL 图形库使用（二） —— 渲染模式、对象、扩展和状态机3. OpenGL 图形库使用（三） —— 着色器、...
LearnOpenGL-CN笔记(二)
Apathetical的博客
11-10 318
光照 颜色 #include <glad/glad.h> #include <glfw3.h> #include <iostream> #include "Shader.h" #include "Camera.h" #define STB_IMAGE_IMPLEMENTATION #include <stb_image.h> #include <glm/glm.hpp> #include <glm/gtc/matrix_transform.h
基础光照
weixin_34150830的博客
11-16 113
一、冯氏光照模型 其主要结构由3个分量组成：环境（ambient）、漫反射（diffuse）、镜面(specular)光照。下边这张图展示了这些分量看起来的样子： 环境光照：即使在黑暗的环境下，世界上通常也仍然有一些光亮（月亮、远处的光），所以物体几乎永远不是完全黑暗的。为了模拟这种效果，我们会使用一个环境光照常量，它永远会给物体一些颜色。 漫反射光照：模拟光源对物体的方向性影响。它是冯...
Low Poly FPS Pack v3.2 Unity
06-22
8. **扩展性**：此资源包可以作为基础，让开发者进一步扩展和定制自己的FPS游戏。例如，添加新的关卡、敌人类型，甚至创建多人在线对战模式。 总的来说，"Low Poly FPS Pack v3.2 Unity" 提供了一套完整的低多边形...
opencv3.2-boostdesc所有东西
11-30
在OpenCV 3.2这个版本中，BoostDesc可能已经过优化，提高了计算效率或者增强了在各种光照、视角变化下的稳定性。如果你正在使用OpenCV 3.2，并且你的项目依赖于BoostDesc，那么这个压缩包可能能帮助你直接替换现有的...
Post Processing Profiles V3.2 - Unity相机镜头VFX特效.zip
08-24
《Unity相机镜头VFX特效：Post Processing Profiles V3.2详解》 Unity引擎以其强大的图形渲染能力和灵活性在游戏开发领域占据一席之地。在创建视觉震撼的游戏体验时，后处理（Post Processing）技术扮演了至关重要...
ThreeJS光照类型详解及示例演示
最新发布
skyunlin的专栏
10-21 890
Three.js是一款强大的3D渲染库，它提供了多种光照类型，让开发者能够创建出更加真实和生动的3D场景。本文将详细讲解Three.js中的光照类型，包括其分类、原理和用法。
learnopengl-cn.zip
08-02
opengl学习资料
Unity Shader基础【四】- 第一个Unity Shader程序（基础光照及纹理）
一个游戏开发的博客
06-26 267
1 基本概念 着色:根据材质属性、光源信息，通过光照模型（Lighting Model)去计算沿某个观察方向的出射度的过程。 逐顶点光照与逐像素光照：逐顶点光照在每个顶点上计算光照，再在渲染图元内部进行线性插值输出像素着色(Gouraud shading)；逐像素光照以每个像素为基础进行光照计算（Phong shading);由于顶点数量远小于像素数量（光栅化为进行像素填充），因此逐顶点光...
LearnOpenGL-CN笔记(一)
Apathetical的博客
10-28 601
配置CMakeLists.txt 环境：MACOS Catalina 10.15.6，CLion cmake_minimum_required(VERSION 3.9) project(RenderTest) set(CMAKE_CXX_STANDARD 11) # 添加头文件 set(GLEW_H /usr/local/Cellar/glew/2.1.0/include/GL) set(GLFW_H /usr/local/Cellar/glfw/3.2.1/include/GLFW) set(GLAD
LearnOpenGL CN学习笔记（一）
weixin_43839880的博客
09-21 181
懒得弄 学习笔记而已
learn opengl 中文_LearnOpenGL-CN
weixin_42300302的博客
01-17 984
LearnOpenGL中文化工程要更新的话请到new-theme分支，这个分支可能会停止更新learnopengl.com系列教程的中文翻译，目前正在翻译中。当前翻译进度：目前状态：请认领一下In Practice下的章节阅读地址目前Host在GitHub上，可以点击这里进行阅读。旧版本的Host在Read The Docs内(不定时更新)，可以点击这里进行阅读。认领翻译由于我们的志愿者来自五湖四...
LearnOpenGL-CN笔记(四)
Apathetical的博客
01-10 515
高级OpenGL 深度测试 #include <glad/glad.h> #include <glfw3.h> #include <iostream> #include "Shader.h" #include "Camera.h" #define STB_IMAGE_IMPLEMENTATION #include <stb_image.h> #include <glm/glm.hpp> #include <glm/gtc/matrix_tra
LearnOpenGL-CN笔记(三)
Apathetical的博客
11-20 266
模型加载 模型 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <glm/glm.hpp> #include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/type_ptr.hpp> #define STB_IMAGE_IMPLEMENTATION #include "Shader.h" #include "Camera.h"
OpenGL视图与模型变换：理解3.2关键概念
在"视图和模型变换 - Cambridge International AS and A Level Physics 2e"中，章节3.2主要讨论了OpenGL中的视图和模型变换，这是3D图形编程中关键的概念。OpenGL中的变换通常涉及组合视图矩阵和模型矩阵，这两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值