【计算机图形学】多种光源+多种材质+天空盒 OpenGL设计实践

已于 2023-12-15 19:42:34 修改
阅读量1.4k 收藏 23
点赞数 34
分类专栏： 计算机图形学 文章标签： 材质 图形渲染 光照贴图 c++ 大作业
于 2023-11-29 15:31:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhushatong/article/details/134690996
版权

OpenGL - TextureAndLights (CG)

全部代码，请前往：https://github.com/Zhu-Shatong/OpenGL-CG-TextureAndLights

如果这篇文章对你有帮助，欢迎点赞与收藏~

项目介绍：

这个基于OpenGL的3D渲染项目专注于实现多种光源、多种材质处理以及天空盒效果的展示。它利用了GLFW、GLAD和GLM库来创建窗口、处理用户输入和进行数学运算。项目的核心在于使用OpenGL渲染技术，展示不同类型的光源（如定向光、点光源和聚光灯）和材质效果（如漫反射和镜面高光贴图）。此外，通过实现天空盒功能，项目增强了3D场景的深度和沉浸感。用户可以通过键盘和鼠标控制相机，观察由多种光源照亮的具有不同材质的物体，以及周围的天空盒环境。

This OpenGL-based 3D rendering project focuses on showcasing multiple light sources, various material handling, and skybox effects. Utilizing libraries such as GLFW, GLAD, and GLM, it creates windows, processes user inputs, and performs mathematical operations. The project’s essence lies in employing OpenGL rendering techniques to display different types of light sources (like directional lights, point lights, and spotlights) and material effects (such as diffuse and specular mapping). Additionally, by implementing the skybox feature, the project enhances the depth and immersion of the 3D scene. Users can control the camera using the keyboard and mouse, observing objects with different materials illuminated by various light sources, surrounded by a skybox environment.

这同时也是 同济大学计算机系 CG 100433 计算机图形学 课程作业 Assignment3。

Programming 作业要求：
• 1. Render several 3D models with more than two types of lights and various materials (textures)
• 2. Add a Skybox to the rendered scene.

https://www.bilibili.com/video/BV1iG411S7TG/

在这里插入图片描述

关键词：

  • OpenGL
  • 计算机图形学 CG
  • 3D渲染
  • 多种光源
  • 多种材质
  • 天空盒 Skybox
  • GLFW
  • GLAD
  • GLM

功能特点：

  1. 多种光源支持：支持不同类型的光源，包括定向光（Directional Light）、点光源（Point Lights）和聚光灯（Spotlight），为场景提供丰富的照明效果。
  2. 多种材质处理：程序能够加载和应用不同的材质贴图，如漫反射贴图（Diffuse Map）、镜面高光贴图（Specular Map）等，提升物体表面的真实感。
  3. 天空盒（Skybox）：实现了天空盒的功能，能够在3D场景中创建一个包裹整个场景的立方体，用于展示周围环境，增强场景的深度和沉浸感。

Features:

  1. Multiple Light Sources: Supports various types of light sources, including directional light, point lights, and spotlights, providing rich lighting effects for the scene.
  2. Multiple Material Handling: The program can load and apply different material textures, such as diffuse maps and specular maps, enhancing the realism of object surfaces.
  3. Skybox: Implements the skybox feature, creating a cube that envelops the entire scene to display the surrounding environment, enhancing the depth and immersion of the scene.

技术栈：

  • OpenGL：用于渲染3D图形。
  • GLFW：提供了创建窗口、接收输入等功能。
  • GLM：用于数学运算，尤其是矩阵变换。
  • GLAD：用于加载OpenGL函数指针。
  • stb_image：用于加载图片文件，作为纹理。

Tech Stack:

  • OpenGL: For rendering 3D graphics.
  • GLFW: For creating windows and handling inputs.
  • GLM: For mathematical operations, especially matrix transformations.
  • GLAD: For loading OpenGL function pointers.
  • stb_image: For loading image files as textures.

主要功能实现：

  • 利用GLFW创建窗口和处理输入。
  • 使用GLAD加载OpenGL函数指针。
  • 实现了基本的3D物体（立方体）的渲染。
  • 加载并应用不同的纹理到3D物体。
  • 实现了基本的相机系统，支持视角转换和缩放。
  • 实现了多种光源和材质的效果。
  • 实现了天空盒，增强了场景的真实感。

Main Implementations:

  • Using GLFW to create windows and handle inputs.
  • Loading OpenGL function pointers with GLAD.
  • Rendering basic 3D objects (cubes).
  • Loading and applying different textures to 3D objects.
  • Implementing a basic camera system supporting view transformation and zoom.
  • Implementing various light sources and material effects.
  • Implementing a skybox to enhance the realism of the scene.

mian.cpp代码 (全部代码，请前往：https://github.com/Zhu-Shatong/OpenGL-CG-TextureAndLights)

/* Zhu Shatong */
#define STB_IMAGE_IMPLEMENTATION

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

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <shader/shader_m.h>
#include <camera.h>
#include <vector>
#include <string>

#include <iostream>
using namespace std;


// 函数原型
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);
unsigned int loadTexture(const char* path);
unsigned int loadCubemap(vector<std::string> faces); // 加载立方体贴图函数


// 屏幕设置 
const unsigned int SCR_WIDTH = 1920;
const unsigned int SCR_HEIGHT = 1080;

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

// 时间
float deltaTime = 0.0f;
float lastFrame = 0.0f;


int main()
{

/************************************************************************************************************/
// 初始化
/************************************************************************************************************/
	
    // glfw: 初始化和配置
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    // glfw 窗口创建
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);

    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // 隐藏鼠标

    // glad: 加载所有 OpenGL 函数指针
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // 开启深度测试
    glEnable(GL_DEPTH_TEST);


/************************************************************************************************************/
// VAO VBO 创建
/************************************************************************************************************/

    float vertices[] = {
        // positions          // normals           // texture coords
        -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
    };
    float skyboxVertices[] = {
        // positions          
        -1.0f,  1.0f, -1.0f,
        -1.0f, -1.0f, -1.0f,
         1.0f, -1.0f, -1.0f,
         1.0f, -1.0f, -1.0f,
         1.0f,  1.0f, -1.0f,
        -1.0f,  1.0f, -1.0f,

        -1.0f, -1.0f,  1.0f,
        -1.0f, -1.0f, -1.0f,
        -1.0f,  1.0f, -1.0f,
        -1.0f,  1.0f, -1.0f,
        -1.0f,  1.0f,  1.0f,
        -1.0f, -1.0f,  1.0f,

         1.0f, -1.0f, -1.0f,
         1.0f, -1.0f,  1.0f,
         1.0f,  1.0f,  1.0f,
         1.0f,  1.0f,  1.0f,
         1.0f,  1.0f, -1.0f,
         1.0f, -1.0f, -1.0f,

        -1.0f, -1.0f,  1.0f,
        -1.0f,  1.0f,  1.0f,
         1.0f,  1.0f,  1.0f,
         1.0f,  1.0f,  1.0f,
         1.0f, -1.0f,  1.0f,
        -1.0f, -1.0f,  1.0f,

        -1.0f,  1.0f, -1.0f,
         1.0f,  1.0f, -1.0f,
         1.0f,  1.0f,  1.0f,
         1.0f,  1.0f,  1.0f,
        -1.0f,  1.0f,  1.0f,
        -1.0f,  1.0f, -1.0f,

        -1.0f, -1.0f, -1.0f,
        -1.0f, -1.0f,  1.0f,
         1.0f, -1.0f, -1.0f,
         1.0f, -1.0f, -1.0f,
        -1.0f, -1.0f,  1.0f,
         1.0f, -1.0f,  1.0f
    };


    // Cube
    unsigned int VBO, cubeVAO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &VBO);

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

    glBindVertexArray(cubeVAO);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0); // 顶点位置
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1); // 顶点法线
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2); // 顶点纹理坐标


    // 点光源的正方体模型的Cube
    unsigned int lightCubeVAO;

    glGenVertexArrays(1, &lightCubeVAO);
    glBindVertexArray(lightCubeVAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO); // 与Cube的VBO绑定相同的VBO，因为数据相同

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


    // skybox VAO
    unsigned int skyboxVAO, skyboxVBO;
    glGenVertexArrays(1, &skyboxVAO);
    glGenBuffers(1, &skyboxVBO);

    glBindVertexArray(skyboxVAO);
    glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);

    glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);


/************************************************************************************************************/
// 材质
/************************************************************************************************************/

    unsigned int diffuseMap = loadTexture("resources/textures/container2.png");
    unsigned int specularMap = loadTexture("resources/textures/container2_specular.png");
    unsigned int brickwall = loadTexture("resources/textures/brickwall.jpg");
    unsigned int metal = loadTexture("resources/textures/metal.png");
    vector<std::string> faces
    {
        "resources/textures/skybox/right.jpg",
        "resources/textures/skybox/left.jpg",
        "resources/textures/skybox/top.jpg",
        "resources/textures/skybox/bottom.jpg",
        "resources/textures/skybox/front.jpg",
        "resources/textures/skybox/back.jpg"
    };
    unsigned int cubemapTexture = loadCubemap(faces);


/************************************************************************************************************/
// Shader
/************************************************************************************************************/

    Shader lightingShader("multiple_lights.vs.glsl", "multiple_lights.fs.glsl"); 
    Shader lightCubeShader("light_cube.vs.glsl", "light_cube.fs.glsl");
    Shader skyboxShader("skybox.vs.glsl", "skybox.fs.glsl");

    lightingShader.use();
    lightingShader.setInt("material.diffuse", 0);
    lightingShader.setInt("material.specular", 1);

    skyboxShader.use();
    skyboxShader.setInt("skybox", 0);


/************************************************************************************************************/
// LOOP
/************************************************************************************************************/

    // positions all containers
    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)
    };
    // positions of the point lights
    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, -6.0f),
        glm::vec3(0.0f,  0.0f, -3.0f)
    };


    while (!glfwWindowShouldClose(window))
    {
        float currentFrame = static_cast<float>(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);
            
            
        /**********************************************************/
        // 视角
        /**********************************************************/
        lightingShader.use();
        lightingShader.setVec3("viewPos", camera.Position);

            
        /**********************************************************/
        // 光照
        /**********************************************************/
            
        lightingShader.use();
        // directional light
        lightingShader.setVec3("dirLight.direction", 0.2f, -1.0f, 0.3f);
        lightingShader.setVec3("dirLight.ambient", 0.05f, 0.05f, 0.05f);
        lightingShader.setVec3("dirLight.diffuse", 0.4f, 0.4f, 0.4f);
        lightingShader.setVec3("dirLight.specular", 0.9f, 0.9f, 0.9f);
        // point light 1
        lightingShader.setVec3("pointLights[0].position", pointLightPositions[0]);
        lightingShader.setVec3("pointLights[0].ambient", 0.05f, 0.00f, 0.00f);
        lightingShader.setVec3("pointLights[0].diffuse", 0.8f, 0.0f, 0.0f);
        lightingShader.setVec3("pointLights[0].specular", 1.0f, 0.0f, 0.0f);
        lightingShader.setFloat("pointLights[0].constant", 1.0f);
        lightingShader.setFloat("pointLights[0].linear", 0.09f);
        lightingShader.setFloat("pointLights[0].quadratic", 0.032f);
        // point light 2
        lightingShader.setVec3("pointLights[1].position", pointLightPositions[1]);
        lightingShader.setVec3("pointLights[1].ambient", 0.00f, 0.05f, 0.00f);
        lightingShader.setVec3("pointLights[1].diffuse", 0.0f, 0.8f, 0.0f);
        lightingShader.setVec3("pointLights[1].specular", 0.0f, 1.0f, 0.0f);
        lightingShader.setFloat("pointLights[1].constant", 1.0f);
        lightingShader.setFloat("pointLights[1].linear", 0.09f);
        lightingShader.setFloat("pointLights[1].quadratic", 0.032f);
        // point light 3
        lightingShader.setVec3("pointLights[2].position", pointLightPositions[2]);
        lightingShader.setVec3("pointLights[2].ambient", 0.00f, 0.00f, 0.05f);
        lightingShader.setVec3("pointLights[2].diffuse", 0.0f, 0.0f, 0.8f);
        lightingShader.setVec3("pointLights[2].specular", 0.0f, 0.0f, 1.0f);
        lightingShader.setFloat("pointLights[2].constant", 1.0f);
        lightingShader.setFloat("pointLights[2].linear", 0.09f);
        lightingShader.setFloat("pointLights[2].quadratic", 0.032f);
        // point light 4
        lightingShader.setVec3("pointLights[3].position", pointLightPositions[3]);
        lightingShader.setVec3("pointLights[3].ambient", 0.05f, 0.05f, 0.05f);
        lightingShader.setVec3("pointLights[3].diffuse", 0.8f, 0.8f, 0.8f);
        lightingShader.setVec3("pointLights[3].specular", 1.0f, 1.0f, 1.0f);
        lightingShader.setFloat("pointLights[3].constant", 1.0f);
        lightingShader.setFloat("pointLights[3].linear", 0.09f);
        lightingShader.setFloat("pointLights[3].quadratic", 0.032f);
        // spotLight
        lightingShader.setVec3("spotLight.position", camera.Position);
        lightingShader.setVec3("spotLight.direction", camera.Front);
        lightingShader.setVec3("spotLight.ambient", 0.0f, 0.0f, 0.0f);
        lightingShader.setVec3("spotLight.diffuse", 1.0f, 1.0f, 1.0f);
        lightingShader.setVec3("spotLight.specular", 1.0f, 1.0f, 1.0f);
        lightingShader.setFloat("spotLight.constant", 1.0f);
        lightingShader.setFloat("spotLight.linear", 0.09f);
        lightingShader.setFloat("spotLight.quadratic", 0.032f);
        lightingShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(12.5f)));
        lightingShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(15.0f)));
            
            
        /**********************************************************/
        // transformations
        /**********************************************************/

        lightingShader.use();

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

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


        /**********************************************************/
        // 开始绘制
        /**********************************************************/

        lightingShader.use();

        // render containers
        glBindVertexArray(cubeVAO);
        for (unsigned int i = 0; i < 10; i++)
        {
            // 先处理纹理
            // Unbind previous textures
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture from GL_TEXTURE0
            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture from GL_TEXTURE1

            // Bind new textures
            if (i < 4) {
                lightingShader.setFloat("material.shininess", 80.0f);
                // bind diffuse map
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D, diffuseMap);
                // bind specular map
                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_2D, specularMap);
            }
            else if (i < 6){
                lightingShader.setFloat("material.shininess", 800.0f);
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D, metal);
                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_2D, metal);
            }
            else {
                lightingShader.setFloat("material.shininess", 50.0f);
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D, brickwall);
                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_2D, brickwall);
            }


            // calculate the model matrix for each object and pass it to shader before drawing
            glm::mat4 model = glm::mat4(1.0f);
            model = glm::translate(model, cubePositions[i]);
            float angle = 20.0f * i;
            model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
            lightingShader.setMat4("model", model);


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



        // also draw the lamp object(s)
        lightCubeShader.use();
        lightCubeShader.setMat4("projection", projection);
        lightCubeShader.setMat4("view", view);

        // we now draw as many light bulbs as we have point lights.
        glm::vec4 customColor[] = {
            glm::vec4(1.0f, 0.0f, 0.0f, 1.0f),
            glm::vec4(0.0f, 1.0f, 0.0f, 1.0f),
            glm::vec4(0.0f, 0.0f, 1.0f, 1.0f),
            glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)
        };
        glBindVertexArray(lightCubeVAO);
        for (unsigned int i = 0; i < 4; i++)
        {

            model = glm::mat4(1.0f);
            model = glm::translate(model, pointLightPositions[i]);
            model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube
            lightCubeShader.setMat4("model", model);

            lightCubeShader.setVec4("lightColor", customColor[i]);

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



        glDepthFunc(GL_LEQUAL);  // 这里需要将深度函数设置为GL_LEQUAL，因为深度值等于远平面的深度值的片段才会在深度缓冲中通过
        skyboxShader.use();
        view = glm::mat4(glm::mat3(camera.GetViewMatrix()));
        skyboxShader.setMat4("view", view);
        skyboxShader.setMat4("projection", projection);
        // skybox cube
        glBindVertexArray(skyboxVAO);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        glBindVertexArray(0);
        glDepthFunc(GL_LESS); // set depth function back to default



        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }



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

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






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

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

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

// glfw: whenever the mouse moves, this callback is called
// -------------------------------------------------------
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
    float xpos = static_cast<float>(xposIn);
    float ypos = static_cast<float>(yposIn);

    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

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

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

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

// utility function for loading a 2D texture from file
// ---------------------------------------------------
unsigned int loadTexture(char const* path)
{
    unsigned int textureID;
    glGenTextures(1, &textureID);

    int width, height, nrComponents;
    unsigned char* data = stbi_load(path, &width, &height, &nrComponents, 0);
    if (data)
    {
        GLenum format;
        if (nrComponents == 1)
            format = GL_RED;
        else if (nrComponents == 3)
            format = GL_RGB;
        else if (nrComponents == 4)
            format = GL_RGBA;

        glBindTexture(GL_TEXTURE_2D, textureID);
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);

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

        stbi_image_free(data);
    }
    else
    {
        std::cout << "Texture failed to load at path: " << path << std::endl;
        stbi_image_free(data);
    }

    return textureID;
}

// loads a cubemap texture from 6 individual texture faces
// order:
// +X (right)
// -X (left)
// +Y (top)
// -Y (bottom)
// +Z (front) 
// -Z (back)
// -------------------------------------------------------
unsigned int loadCubemap(vector<std::string> faces) // 加载立方体贴图函数
{
    unsigned int textureID; // 纹理ID
    glGenTextures(1, &textureID); // 生成纹理
    glBindTexture(GL_TEXTURE_CUBE_MAP, textureID); // 绑定纹理

    int width, height, nrChannels; // 图片宽度、高度、颜色通道数
    for (unsigned int i = 0; i < faces.size(); i++)
    {
        unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0); // 加载图片
        if (data)
        {
            glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); // 生成纹理
            stbi_image_free(data);
        }
        else
        {
            std::cout << "Cubemap texture failed to load at path: " << faces[i] << std::endl;
            stbi_image_free(data);
        }
    }
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 设置纹理过滤方式
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 设置纹理过滤方式
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // 设置纹理环绕方式
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // 设置纹理环绕方式
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // 设置纹理环绕方式

    return textureID; // 返回纹理ID
}

To run the program, follow the instructions below. (using Visual Studio)

Getting Started

  1. Download and unzip the Assignment3-TextureAndLights.zip file.

  2. Open Visual Studio 2022 (or later).

  3. Click on File > Open > Project/Solution.

  4. Navigate to the unzipped folder and select Assignment3-TextureAndLights.sln.
    在这里插入图片描述

    Note: If you are using a Visual Studio version earlier than 2022 (e.g., 2019 or lower), follow these additional steps:

    • Right-click on the project in the Solution Explorer.
    • Select Properties.
    • Under General, go to Platform Toolset and choose the corresponding version.
    • image-20231128133106611

  5. Press F5 to build and run the program.

Requirements

  • Visual Studio 2022 or later (or earlier versions with adjustments as mentioned above).

Additional Configuration

To enhance the portability of the project and ensure that downloaders can run it seamlessly, we’ve made the following modifications to the project settings.

Users don’t need to perform these actions; this is provided for informational purposes.

Include Directories

We’ve added the following paths to the project’s include directories:

  • $(ProjectDir)include
  • $(IncludePath)

This ensures that the project can locate necessary header files and dependencies without manual configuration.

Library Directories

We’ve included the following paths in the project’s library directories:

  • $(ProjectDir)lib
  • $(LibraryPath)

By doing so, we make sure that the project can find required libraries and link them correctly during compilation.

These modifications have been made to simplify the setup process for users and promote the project’s portability.

image-20231128133148724
如果这篇文章对你有帮助，欢迎点赞与收藏~

全部代码，请前往：https://github.com/Zhu-Shatong/OpenGL-CG-TextureAndLights

zhushatong
关注
  • 34
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
openGL天空盒实现
03-10
天空盒的概念非常巧妙而又简单： （1）实例化一个立方体对象； （2）将立方体的纹理设置为所需的环境； （3）将立方体围绕相机放置。
使用Opengl实现天空盒
rabbit729的专栏
08-28 5141
 使用OpenGL实现的天空盒和地形，由于没采用多重纹理效果不是很理想     
OpenGL 天空盒
03-17
vs2010下用c++和OpenGL实现的天空盒， 图片加载采用的是jpeg库
OPENGL天空盒
10-30
OPENGL中的摄像漫游技术，可以通过摄像机对三围场景进行摄像漫游。
OpenGL天空盒
04-23
使用立方体贴图技术，实现天空盒功能，提供了两套天空盒图片。本人博客：https://blog.csdn.net/lady_killer9/article/details/89468950
计算机图形学光源移动论文.docx
08-06
与计算机图形学实践教程第2版源程序，是一个效果，不过这个代码比较简单 彩色小球的光源移动论文，有3个不同的光照射在白色小球上，展示不同的颜色，设计内包含真实代码，且备注较为清晰，c++一个页面即可运行，如果...
计算机图形学 OpenGL实验源码+实验文档
12-05
实验一 OpenGL+GLUT开发平台搭建 5 小实验1： 开发环境设置 5 小实验2： 控制窗口位置和大小 6 小实验3：默认的可视化范围 6 小实验4：自定义可视化范围 7 小实验5： 几何对象变形的原因 8 小实验6： 视口坐标系及...
计算机图形学实验及课程设计.zip
05-27
包含计算机图形学课程所有实验程序文件，并带有反汇编软件，打开后将exe程序拖入其中即可修改程序信息，使用方法简单，可无师自通。
计算机图形学实验2 移动光源
06-29
计算机图形学实验2 移动光源绘制犹他茶壶实验鼠标和键盘交互能够移动光源改变材质
计算机图形学——太阳系漫游.rar
10-04
（2）具有光照、阴影效果，光源的类型至少有2 种； （3）用户可交互实现视角切换完成对场景的任意角度浏览； （4）允许用户通过键盘或者鼠标实现对场景中至少两个物体进行交互控制 （例如移动，旋转，缩放等）。
天空盒(opengl)
12-25
这个程序包括天空盒，雾的效果，和背景音乐
OPENGL天空盒Skybox
06-09
OpenGL实现的天空盒
Qt OpenGL 天空盒
06-17
Qt OpenGL 天空盒
opengl完美天空盒
11-17
opengl完美天空盒 天空盒无缝连接 有CS模仿和背景音效！！绚丽
OpenGL天空盒.zip
12-09
使用立方体贴图技术，实现天空盒功能，提供了两套天空盒图片。
OpenGL 天空盒的实现
12-24
OpenGL 天空盒的实现
opengl天空盒的效果源代码
12-17
opengl纹理贴图，光照，视口的综合运用
【OC和红移的双面材质】
最新发布
zszwebart的博客
04-29 97
rsoc评论(0)
Bentley二次开发教程22-文件及模型管理-材质、图层
不见不散的博客
04-24 512
材质主要用于对元素进行材质贴图，以表现实际的材料样式。材质表中包含材质表，材质面板以及材质。而其属性记录了反射等多种属性以表达实际材质效果。
计算机图形学opengl实验8茶壶光照加提高
11-10
计算机图形学中，OpenGL是一个常用的图形处理库，可以用来进行各种图形渲染和图形处理操作。在OpenGL实验8中，茶壶光照是一个常见的实验内容，通过增加光照效果可以提高茶壶的真实感和视觉效果。 在实验8中，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值