Opengl-模板测试（物体轮廓(Object Outlining)）

于 2024-02-19 10:43:57 发布
阅读量467 收藏 11
点赞数 9
分类专栏： Opengl 文章标签： unity 游戏引擎 技术美术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muziiii/article/details/136164457
版权

各位老师们，我们现在实现的是用模板测试的特性实现的一个物体物体轮廓(Object Outlining)的一个效果。

实现思路：

        1.渲染地板：不写入模板缓冲区。
        2.渲染cube：写入模板缓冲区，设置像素模板值为1。
        3.渲染边框：修改cube模型矩阵，微微放大cube模板，用GL_NOTEQUAL将模板值不为1的像素渲染出来。

我们来看看核心代码叭！

 //1.地板的绘制：不写入模板缓冲区
        glStencilMask(0x00);
        // floor
        glBindVertexArray(planeVAO);
        glBindTexture(GL_TEXTURE_2D, floorTexture);
        shader.setMat4("model", glm::mat4(1.0f));
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);

        //2.cube的绘制：写入模板缓冲区
        glStencilFunc(GL_ALWAYS, 1, 0xFF);
        glStencilMask(0xFF);//所有这些单元都将被考虑，并且它们都将被写入或读取。
        // cubes
        glBindVertexArray(cubeVAO);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // 3.这段代码的目的是使用模板测试来绘制对象的边界，并且禁用深度测试以确保所有的像素都被绘制
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);//GL_NOTEQUAL表示模板测试将检查像素的模板值是否不等于1。如果等于1，则该像素将被视为失败。
        glStencilMask(0x00);//模板掩码被设置为0，意味着模板缓冲区中的这些单元不会被读取或写入。
        glDisable(GL_DEPTH_TEST);//禁用了深度测试:禁用深度测试意味着所有的像素都会被绘制，不考虑它们的深度值
        shaderSingleColor.use();
        float scale = 1.1f;//将立方体稍微放大一些
        //之前cube已经被渲染出现了这里渲染边框，我们用glStencilFunc函数中GL_NOTEQUAL来将模板值等于1的的像素排除在外，然后这一次我们用的模型矩阵会使得立方体稍微放大一些，
        // 且用GL_NOTEQUAL来将模板值等于1的的像素排除在外，然后模板掩码被设置为0，模板缓冲区不会写入读取，加上又禁用了深度测试，其实就能刚刚好将立方体的边框完全渲染出来
        
        // cubes
        glBindVertexArray(cubeVAO);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        glBindVertexArray(0);
        glStencilMask(0xFF);
        glStencilFunc(GL_ALWAYS, 0, 0xFF);
        glEnable(GL_DEPTH_TEST);

 我猜肯定有老师想看看原代码叭？以下是全部的代码o！

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

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

//#include <learnopengl/filesystem.h>
#include <learnopengl/shader_m.h>
#include <learnopengl/camera.h>
#include <learnopengl/model.h>

#include <iostream>

#include "ResLoad.h"
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);

const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

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()
{
    glfwInit();
    //OpenGL上下文的主要版本为3,应用程序将使用OpenGL 3.x的特性
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    //OpenGL上下文的次要版本为3,应用程序将使用OpenGL 3.3的特性
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    //OpenGL上下文的核心模式(核心模式意味着OpenGL将使用最新的、没有废弃的特性，并且不包含任何的扩展或遗留功能)
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

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

    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "OpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();//终止GLFW库的实例，因为在某些平台上，如果不调用这个函数，程序可能无法正常退出。
        return -1;//由于窗口创建失败，这行代码将返回-1，表示程序出错
    }
    glfwMakeContextCurrent(window);//指定的窗口的上下文设置为当前线程的主上下文
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); //当帧缓冲（把颜色缓冲、深度缓冲和模板缓冲结合起来就是帧缓冲）大小改变时，该回调函数将被调用
    glfwSetCursorPosCallback(window, mouse_callback);//当鼠标位置改变时，该回调函数将被调用
    glfwSetScrollCallback(window, scroll_callback);//处理滚动事件

    //告诉GLFW库捕获鼠标输入,GLFW_CURSOR：使用鼠标光标
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR/*GLFW_CURSOR_DISABLED*/);

    //使用GLAD库来加载所有的OpenGL函数指针
    // (GLADloadproc)glfwGetProcAddress 是一个函数指针，它指向一个用于获取OpenGL函数地址的函数
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        //如果GLAD库无法初始化（即无法加载OpenGL函数指针），这行代码会输出一个错误消息
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    //表示在加载模型时垂直翻转纹理,这在某些3D模型中是必要的，因为纹理的坐标可能与模型的坐标不同步。
    stbi_set_flip_vertically_on_load(true);

    //启用深度测试:深度测试是OpenGL中用于确定哪些像素应该被绘制在前面的其他像素之上的过程
    glEnable(GL_DEPTH_TEST);//深度缓冲中的值在屏幕空间中不是线性的（在透视矩阵应用之前在观察空间中是线性的）
    glEnable(GL_ALWAYS);// 永远通过深度测试

    //启用模板测试
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_NOTEQUAL, 1, 0xFF);//GL_NOTEQUAL当模板缓冲中的值不等于给定的值（在这里是1）时，0xFF(所有的像素都会进行模板测试):模板测试才会通过 哪个像素或哪些像素应用模板测试
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);//当模板测试通过时，用指定的值替换当前值

    //Shader ourShader("D:/OpenGL/OpenGLearn/OpenGLearn/resources/Shader/8.modelloading/8.modelloading.vs", "D:/OpenGL/OpenGLearn/OpenGLearn/resources/Shader/8.modelloading/8.modelloading.fs");
    //Model ourModel(/*FileSystem::getPath(*/"D:/OpenGL/OpenGLearn/OpenGLearn/resources/objects/cyborg/cyborg.obj"/*)*/);

    Shader shader(Res::ResLoad::GetShaderPath("8.modelloading/8.modelloading.vs").c_str(), Res::ResLoad::GetShaderPath("8.modelloading/8.modelloading.fs").c_str());
    Shader shaderSingleColor(Res::ResLoad::GetShaderPath("9.stencil_testing/9.stencil_testing.vs").c_str(), Res::ResLoad::GetShaderPath("9.stencil_testing/shaderSingleColor.fs").c_str());

    float cubeVertices[] = {
       -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
    };
    float planeVertices[] = {
         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,

         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
         5.0f, -0.5f, -5.0f,  2.0f, 2.0f
    };

    // cube VAO
    unsigned int cubeVAO, cubeVBO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &cubeVBO);
    glBindVertexArray(cubeVAO);
    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glBindVertexArray(0);
    // plane VAO
    unsigned int planeVAO, planeVBO;
    glGenVertexArrays(1, &planeVAO);
    glGenBuffers(1, &planeVBO);
    glBindVertexArray(planeVAO);
    glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glBindVertexArray(0);

    unsigned int cubeTexture = loadTexture(Res::ResLoad::GetTexturePath("marble.jpg").c_str());
    unsigned int floorTexture = loadTexture(Res::ResLoad::GetTexturePath("metal.png").c_str());

    shader.use();
    shader.setInt("texture1", 0);

    //这是一个while循环，它将持续执行，直到用户关闭GLFW窗口
    while (!glfwWindowShouldClose(window))
    {
        //获取当前时间，并将其转换为浮点数。这个时间将用于计算帧之间的时间差
        float currentFrame = static_cast<float>(glfwGetTime());
        //计算当前帧与上一帧之间的时间差。这对于实现平滑动画和物理模拟非常重要。
        deltaTime = currentFrame - lastFrame;
        //更新lastFrame为当前时间，以便在下一次循环中计算新的deltaTime。
        lastFrame = currentFrame;

        // 处理用户输入。这可能包括处理键盘和鼠标事件，例如移动相机或选择对象
        processInput(window);

        //设置背景颜色
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);//清除颜色和深度缓冲区和模板缓冲区，为新的渲染帧做准备。

        // set uniforms
        shaderSingleColor.use();
        glm::mat4 model = glm::mat4(1.0f);
        glm::mat4 view = camera.GetViewMatrix();
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        shaderSingleColor.setMat4("view", view);
        shaderSingleColor.setMat4("projection", projection);

        shader.use();
        shader.setMat4("view", view);
        shader.setMat4("projection", projection);

        //1.地板的绘制：不写入模板缓冲区
        glStencilMask(0x00);
        // floor
        glBindVertexArray(planeVAO);
        glBindTexture(GL_TEXTURE_2D, floorTexture);
        shader.setMat4("model", glm::mat4(1.0f));
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);

        //2.cube的绘制：写入模板缓冲区
        glStencilFunc(GL_ALWAYS, 1, 0xFF);
        glStencilMask(0xFF);//所有这些单元都将被考虑，并且它们都将被写入或读取。
        // cubes
        glBindVertexArray(cubeVAO);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // 3.这段代码的目的是使用模板测试来绘制对象的边界，并且禁用深度测试以确保所有的像素都被绘制
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);//GL_NOTEQUAL表示模板测试将检查像素的模板值是否不等于1。如果等于1，则该像素将被视为失败。
        glStencilMask(0x00);//模板掩码被设置为0，意味着模板缓冲区中的这些单元不会被读取或写入。
        glDisable(GL_DEPTH_TEST);//禁用了深度测试:禁用深度测试意味着所有的像素都会被绘制，不考虑它们的深度值
        shaderSingleColor.use();
        float scale = 1.1f;//将立方体稍微放大一些
        //之前cube已经被渲染出现了这里渲染边框，我们用glStencilFunc函数中GL_NOTEQUAL来将模板值等于1的的像素排除在外，然后这一次我们用的模型矩阵会使得立方体稍微放大一些，
        // 且用GL_NOTEQUAL来将模板值等于1的的像素排除在外，然后模板掩码被设置为0，模板缓冲区不会写入读取，加上又禁用了深度测试，其实就能刚刚好将立方体的边框完全渲染出来
        //物体轮廓渲染效果总结：1.渲染地板：不写入模板缓冲区
                             // 2.渲染cube：写入模板缓冲区，设置像素模板值为1
                             // 3.渲染边框：修改cube模型矩阵，微微放大cube模板，用GL_NOTEQUAL将模板值不为1的像素渲染出来
        
        // cubes
        glBindVertexArray(cubeVAO);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        glBindVertexArray(0);
        glStencilMask(0xFF);
        glStencilFunc(GL_ALWAYS, 0, 0xFF);
        glEnable(GL_DEPTH_TEST);

        // 交换前后缓冲区，显示渲染的结果。这使得新的一帧能够显示在屏幕上。
        glfwSwapBuffers(window);
        glfwPollEvents();//轮询事件，如按键、鼠标移动等。这对于确保程序响应用户输入非常重要
    }
    // optional: de-allocate all resources once they've outlived their purpose:
    glDeleteVertexArrays(1, &cubeVAO);
    glDeleteVertexArrays(1, &planeVAO);
    glDeleteBuffers(1, &cubeVBO);
    glDeleteBuffers(1, &planeVBO);

    //终止GLFW库，释放之前分配的所有资源。这是程序结束时应该做的清理工作。
    glfwTerminate();
    return 0;
}

void processInput(GLFWwindow* window)
{
    //如果用户按下了“Escape”键（其GLFW键码是GLFW_KEY_ESCAPE），那么这个函数会告诉GLFW关闭当前窗口
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

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

// 用于处理窗口大小改变的事件,当窗口大小发生变化时（无论是由于操作系统还是用户调整大小），这个回调函数就会被执行。
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    //用来确保视口的大小与新的窗口大小相匹配
    glViewport(0, 0, width, height);//第一个和第二个参数（0, 0）定义了视口的左下角位置。
}

// 处理鼠标移动事件,当鼠标在窗口中移动时，这个回调函数就会被执行。
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
    float xpos = static_cast<float>(xposIn);
    float ypos = static_cast<float>(yposIn);

    if (firstMouse)//是否是第一次移动鼠标。如果是第一次移动鼠标，则初始化lastX和lastY为当前鼠标的位置。
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }
    //计算鼠标的x和y偏移量。
    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; //y偏移量的计算是反向的，因为y坐标从窗口的底部开始计数而不是顶部。

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);//调用camera对象的ProcessMouseMovement方法，并传递x和y偏移量作为参数。这通常用于旋转或平移相机视图。
}

//调用camera对象的ProcessMouseScroll方法，并传递y方向的滚动偏移量作为参数。
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    //调用camera对象的ProcessMouseScroll方法，并传递y方向的滚动偏移量作为参数。
    camera.ProcessMouseScroll(static_cast<float>(yoffset));
}

unsigned int loadTexture(char const* path)
{
    unsigned int textureID;
    glGenTextures(1, &textureID);//生成一个新的纹理对象，并将其ID存储在textureID中

    int width, height, nrComponents;
    unsigned char* data = stbi_load(path, &width, &height, &nrComponents, 0);//STB图像库的stbi_load函数加载图像文件,并且更新w,h,n的值
    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);//绑定之前生成的2D纹理对象
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);//使用OpenGL的glTexImage2D函数将图像数据上传到纹理对象
        glGenerateMipmap(GL_TEXTURE_2D);//生成mipmap，这是一种用于平滑纹理在不同缩放级别之间过渡的技术。

        //设置纹理的环绕和过滤方式
        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;
}

以下是效果图o！

木木娅.
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL学习之模板测试绘制模型的轮廓
Jeson_DeveloperWX
12-14 2877
1、本次试验是参考LearnOpenGL网站进行学习总结。有关模板测试的概念和原理请查看学习网站即可，这里就不做解释。 2、再啰嗦一下绘制轮廓的主要步骤： (1).在绘制物体前，把模板方程设置为GL_ALWAYS，用1更新物体将被渲染的片段。 (2).渲染物体，写入模板缓冲。 (3).关闭模板写入和深度测试。 (4).每个物体放大一点点。 (5).使用一个不同的片段着色器用来输出一个纯颜色。 (6...
opengl模型提取轮廓
03-01
在opengl中绘制模型，利用模板缓冲区提取绘制需要提取轮廓的模型，并得到一张二值图（2维矩阵），最用利用opencv提取轮廓
OpenGL绘制的鱼轮廓曲线
03-21
使用18个控制点绘制6组三次Bezier曲线鱼轮廓，可以通过调节控制点，控制鱼轮廓生成形状。
opengl绘制三维模型轮廓实例
03-17
运用opengl混合绘制三维物体轮廓，实现非常简单，绘制效率高。包含源代码和可执行程序。
【Qt OpenGL教程】14：轮廓字体
cly116的博客
08-05 4869
这次教程中，我将教大家绘制3D的轮廓字体，当然肯定不是贴图方式了，它们可像一般的3D模型一样进行旋转，放缩。
OpenGL生成轮廓
weixin_34252090的博客
12-21 1277
2019独角兽企业重金招聘Python工程师标准>>> ...
物流仓储管理ppt模板.ppt
02-08
"物流仓储管理ppt模板.ppt" 根据提供的文件信息，我们可以生成以下几个知识点： 1. PowerPoint的基本概念：PowerPoint是一种complete presentation graphic package，提供了所有需要的工具来制作专业的演示文稿。...
星空互联网科技感PPT模板.pptx
最新发布
04-12
星空互联网科技感PPT模板.pptx 通过对星空互联网科技感PPT模板.pptx的分析，我们可以提取以下知识点： Presentation Software * Presentation software 是一种易于使用的工具，可以帮助用户快速创建专业的演示...
医院医生ppt模板.ppt
02-13
6. **易用性**：PowerPoint 提供的“word processing, outlining, drawing, graphing, and presentation management tools”是一整套完整的工具集，旨在简化创建和编辑过程，使得非设计背景的医疗从业者也能轻松制作...
现代化高端商务PPT模板.pptx
02-09
【现代化高端商务PPT模板】是一种专为商业领域设计的专业演示文稿模板，旨在帮助用户创建具有现代感和高端感的商务演示。该模板通常包含了精心设计的布局、色彩搭配和图形元素，确保你的演讲内容呈现出专业且...
炫彩缤纷商务公司简介PPT模板2
11-23
2. **Outlining**（大纲制作）：通过设置大纲层级，为幻灯片提供逻辑清晰的框架结构，便于后续内容的填充和调整。 3. **Drawing Tools**（绘图工具）：使用绘图工具绘制自定义图形或添加矢量图标，提高模板的视觉...
OpenGL 笔记(二) 图元的属性 - 概念、轮廓
bangce8949的博客
08-26 165
颜色模型 RGB / RGBA glColor* (…); // 默认α是255 对于颜色，帧缓存实际上存储整数值，所以如果用浮点数会对其进行转换。 颜色索引 glIndex&(colorIndex); //用颜色表来指定颜色 glutSetColor(index, red, green, blue); //为给...
[OpenGL(Win32)] - 3D 轮廓字体
weixin_30760895的博客
02-22 80
GLUT库(v1.1)：http://files.cnblogs.com/hcbin/glutdlls37beta.zip 注：暂时只支持英文 //注：本人使用VS2008创建此程序/*1.VS2008->"新建"->"项目"->"VisualC++"->选择"空项目"->输入名称"test.sln"2.在test项目的"解决方案资...
OpenG 轮廓检测
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-20 594
OpenGL轮廓检测OpenGL轮廓检测简介源代码剖析主要源代码 OpenGL轮廓检测简介 今天，我们将讨论如何找到对象的轮廓。明确地说，我说的是3D对象的轮廓，是当光线沿任意方向入射时获得的轮廓。移动光源时，轮廓将相应变化。这与检测图像空间中的轮廓存在根本区别，后者在于在2D图像中找到对象的边界（并且不取决于光源的位置）。尽管轮廓检测主题本身很有趣，但对我而言，这是实现“模板阴影体积”技术的第一步。这是一种阴影渲染技术，在处理点源时特别有用。我们将在下一课中对其进行研究（您可以直接学习）。 在上图中，轮廓
（一）CGAL库应用：指定平面切割模型并用openGL显示该层面轮廓
baidu_41647951的博客
03-23 3122
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
opengl学习-利用模板测试勾画物体轮廓中出现的一个问题
weixin_30606669的博客
01-03 207
我在学习OpenGL模板测试勾画物体轮廓的时候，出现了这个问题: 这个出现的原因就是，改变摄像机的时候，每次绘制，上次绘制中模板缓冲区的数据没有清除的原因。也就是在while循环开始的时候，glClear(GL_STENCIL_BUFFER_BIT);没有起作用，原来 我在while的末尾忘记了修改回来模板缓冲区为可写。glStencilMask(0xff); 转载于:https://ww...
[OpenGL] 基于屏幕空间的轮廓线提取
(ง •̀_•́)ง
01-13 3139
  概念引入          《Real-time Rendering》一书中介绍了多种轮廓线提取的方式，根据对比以及综合考虑，最终使用了图像空间的方法来实现实时提取轮廓。该方法需要先将场景中的物体信息先渲染到纹理中，对使用延迟渲染的框架非常友好，并且弊端也是多种轮廓线提取方法中比较少的，具体内容可以参照原书的NPR章节。 方法概述           (1) 准备2个颜色缓冲区，1...
OpenGL面细节
zhazhiqiang2010的专栏
05-22 707
【原文：http://blog.sina.com.cn/s/blog_8e0502b7010198o5.html】 在OpenGL中面的基本单位是凸多边形。而一般绘制时，多边形的正面、反面两个面均以填充形式进行绘制。下面介绍绘制方式可以如何改变。（材质贴图内容太多以后再展开写）     一、点、轮廓或实心形式     void glPolygonMode(GLen
[OpenGL] 简单的物体描边效果
(ง •̀_•́)ง
10-03 4463
    开发环境：Qt, OpenGL         主要是为了练习glsl写的一个小例子，本身没有什么难度。         思路一：进行两次绘制。在顶点着色器中，第一次只绘制背面，将顶点沿着法线方向进行移动，可以使物体"膨胀"起来，使用描边的纯色填充，第一次渲出来的图像就是一个稍大一点的纯色物体。第二次正常绘制正面，此时尚未进行清屏，所以第二次绘制结果会叠加在第一次的结果上。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值