opengl之几何着色器（2D房子）

最新推荐文章于 2023-04-27 19:48:13 发布
最新推荐文章于 2023-04-27 19:48:13 发布
阅读量683 收藏 3
点赞数 1
分类专栏： opengl学习 图形学 文章标签： 着色器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqdqwass/article/details/120195164
版权

官方文章

opengl之及和着色器

概念

在这里插入图片描述

  • 在顶点和片段着色器之间有一个可选的几何着色器(Geometry Shader)，几何着色器的输入是一个图元（如点或三角形）的一组顶点。几何着色器可以在顶点发送到下一着色器阶段之前对它们随意变换。然而，几何着色器最有趣的地方在于，它能够将（这一组）顶点变换为完全不同的图元，并且还能生成比原来更多的顶点。
  • 用于传递的接口块：
in gl_Vertex
{
    vec4  gl_Position;
    float gl_PointSize;
    float gl_ClipDistance[];
} gl_in[];
  • 顶点着色器
#version 330 core
//在in关键字前声明一个布局修饰符(Layout Qualifier)。
//这个输入布局修饰符可以从顶点着色器接收下列任何一个图元值
layout (points) in;	//通过这里的in和out来进行传值
layout (line_strip, max_vertices = 2) out;	//要变成三角形max_vertices 就必须变为3；话线就是2

void main() {   
	//这里先取值再画图源，连城线 
    gl_Position = gl_in[0].gl_Position + vec4(-0.1, 0.0, 0.0, 0.0); 	//这里如果是三角形gl_in[I]就有123
    EmitVertex();

    gl_Position = gl_in[0].gl_Position + vec4( 0.1, 0.0, 0.0, 0.0);
    EmitVertex();

    EndPrimitive();
}
  • 每次我们调用EmitVertex时，gl_Position中的向量会被添加到图元中来。当EndPrimitive被调用时，所有发射出的(Emitted)顶点都会合成为指定的输出渲染图元。在一个或多个EmitVertex调用之后重复调用EndPrimitive能够生成多个图元。在这个例子中，我们发射了两个顶点，它们从原始顶点位置平移了一段距离，之后调用了EndPrimitive，将这两个顶点合成为一个包含两个顶点的线条

-在主函数中 几何绘画4个点

glDrawArrays(GL_POINTS, 0, 4);
  • 效果
    在这里插入图片描述
  • GL_LINES和GL_LINE_STRIP的区别：
    GL_LINES：每一对顶点被解释为一条直线
    GL_LINE_STRIP：一系列连续的顶点被解释为一条直线
    还有很多别的
    在这里插入图片描述

使用几何着色器

  • 为了展示几何着色器的用法，我们将会渲染一个非常简单的场景，我们只会在标准化设备坐标的z平面上绘制四个点。这些点的坐标是：
float points[] = {
    -0.5f,  0.5f, // 左上
     0.5f,  0.5f, // 右上
     0.5f, -0.5f, // 右下
    -0.5f, -0.5f  // 左下
};
  • 本顶点着色器：
#version 330 core
layout (location = 0) in vec2 aPos;

void main()
{
    gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0); 
}

  • 之前的都是用过，但是现在我们将会添加一个几何着色器，为场景添加活力。

    出于学习目的，我们将会创建一个传递(Pass-through)几何着色器，它会接收一个点图元，并直接将它传递(Pass)到下一个着色器：

#version 330 core
out vec4 FragColor;

void main()
{
    FragColor = vec4(0.0, 1.0, 0.0, 1.0);   
}
  • 为点的顶点数据生成一个VAO和一个VBO，然后使用glDrawArrays进行绘制：
shader.use();
glBindVertexArray(VAO);
glDrawArrays(GL_POINTS, 0, 4);

在这里插入图片描述

  • 创建一个传递(Pass-through)几何着色器，它会接收一个点图元，并直接将它传递(Pass)到下一个着色器
#version 330 core
layout (points) in;
layout (points, max_vertices = 1) out;//这里我们就弄一个点

void main() {    
    gl_Position = gl_in[0].gl_Position; 
    EmitVertex();
    EndPrimitive();
}

  • 现在这个几何着色器应该很容易理解了，它**只是将它接收到的顶点位置不作修改直接发射出去，并生成一个点图元。**现在还什么都没干

    和顶点与片段着色器一样，几何着色器也需要编译和链接，但这次在创建着色器时我们将会使用GL_GEOMETRY_SHADER作为着色器类型：

geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geometryShader, 1, &gShaderCode, NULL);
glCompileShader(geometryShader);  
...
glAttachShader(program, geometryShader);
glLinkProgram(program);

例：造几个房子

  • 修改shader:
    1修改已给代码的useShader命名，保持和原文一致
    2修改shader的生成：const char* geometryPath = nullptr
    3删除原有的shader.cpp，全部用在shader.h的封装之中
#ifndef SHADER_H
#define SHADER_H

#include <glad/glad.h>
#include <glm/glm.hpp>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader
{
public:
    unsigned int ID;
    // constructor generates the shader on the fly
    // ------------------------------------------------------------------------
    //没有第三个参数指针就会进行一个判断就会和以前加载两个指针的效果一样
    Shader(const char* vertexPath, const char* fragmentPath, const char* geometryPath = nullptr)
    {
        // 1. retrieve the vertex/fragment source code from filePath
        std::string vertexCode;
        std::string fragmentCode;
        std::string geometryCode;
        std::ifstream vShaderFile;
        std::ifstream fShaderFile;
        std::ifstream gShaderFile;
        // ensure ifstream objects can throw exceptions:
        vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        try
        {
            // open files
            vShaderFile.open(vertexPath);
            fShaderFile.open(fragmentPath);
            std::stringstream vShaderStream, fShaderStream;
            // read file's buffer contents into streams
            vShaderStream << vShaderFile.rdbuf();
            fShaderStream << fShaderFile.rdbuf();
            // close file handlers
            vShaderFile.close();
            fShaderFile.close();
            // convert stream into string
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
            // if geometry shader path is present, also load a geometry shader
            if (geometryPath != nullptr)
            {
                gShaderFile.open(geometryPath);
                std::stringstream gShaderStream;
                gShaderStream << gShaderFile.rdbuf();
                gShaderFile.close();
                geometryCode = gShaderStream.str();
            }
        }
        catch (std::ifstream::failure e)
        {
            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
        }
        const char* vShaderCode = vertexCode.c_str();
        const char* fShaderCode = fragmentCode.c_str();
        // 2. compile shaders
        unsigned int vertex, fragment;
        // vertex shader
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex, 1, &vShaderCode, NULL);
        glCompileShader(vertex);
        checkCompileErrors(vertex, "VERTEX");
        // fragment Shader
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment, 1, &fShaderCode, NULL);
        glCompileShader(fragment);
        checkCompileErrors(fragment, "FRAGMENT");
        // if geometry shader is given, compile geometry shader
        unsigned int geometry;
        if (geometryPath != nullptr)
        {
            const char* gShaderCode = geometryCode.c_str();
            geometry = glCreateShader(GL_GEOMETRY_SHADER);
            glShaderSource(geometry, 1, &gShaderCode, NULL);
            glCompileShader(geometry);
            checkCompileErrors(geometry, "GEOMETRY");
        }
        // shader Program
        ID = glCreateProgram();
        glAttachShader(ID, vertex);
        glAttachShader(ID, fragment);
        if (geometryPath != nullptr)
            glAttachShader(ID, geometry);
        glLinkProgram(ID);
        checkCompileErrors(ID, "PROGRAM");
        // delete the shaders as they're linked into our program now and no longer necessery
        glDeleteShader(vertex);
        glDeleteShader(fragment);
        if (geometryPath != nullptr)
            glDeleteShader(geometry);

    }
    // activate the shader
    // ------------------------------------------------------------------------
    void useShader()
    {
        glUseProgram(ID);
    }
    // utility uniform functions
    // ------------------------------------------------------------------------
    void setBool(const std::string& name, bool value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
    }
    // ------------------------------------------------------------------------
    void setInt(const std::string& name, int value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
    }
    // ------------------------------------------------------------------------
    void setFloat(const std::string& name, float value) const
    {
        glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
    }
    // ------------------------------------------------------------------------
    void setVec2(const std::string& name, const glm::vec2& value) const
    {
        glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec2(const std::string& name, float x, float y) const
    {
        glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
    }
    // ------------------------------------------------------------------------
    void setVec3(const std::string& name, const glm::vec3& value) const
    {
        glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec3(const std::string& name, float x, float y, float z) const
    {
        glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
    }
    // ------------------------------------------------------------------------
    void setVec4(const std::string& name, const glm::vec4& value) const
    {
        glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec4(const std::string& name, float x, float y, float z, float w)
    {
        glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
    }
    // ------------------------------------------------------------------------
    void setMat2(const std::string& name, const glm::mat2& mat) const
    {
        glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }
    // ------------------------------------------------------------------------
    void setMat3(const std::string& name, const glm::mat3& mat) const
    {
        glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }
    // ------------------------------------------------------------------------
    void setMat4(const std::string& name, const glm::mat4& mat) const
    {
        glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }

private:
    // utility function for checking shader compilation/linking errors.
    // ------------------------------------------------------------------------
    void checkCompileErrors(GLuint shader, std::string type)
    {
        GLint success;
        GLchar infoLog[1024];
        if (type != "PROGRAM")
        {
            glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
            if (!success)
            {
                glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
        else
        {
            glGetProgramiv(shader, GL_LINK_STATUS, &success);
            if (!success)
            {
                glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
    }
};
#endif
  • 顶点着色器和片段着色器代码：
  • 因为几何着色器是作用于输入的一组顶点的，从顶点着色器发来输入数据总是会以数组的形式表示出来，即便我们现在只有一个顶点。

我们并

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

//用接口块传递
out VS_OUT{
	vec3 color;
}vs_out;

//out vec3 fColor;
void main()
{
	vs_out.color=aColor;
	
    gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0); 
}

#version 330 core
out vec4 FragColor;

in vec3 fColor;

void main()
{
    FragColor = vec4(fColor, 1.0);   
}
  • 几何着色器：
    1.注意图源的输出方式：每个顶点都是原始点的位置加上一个偏移量，来组成一个大的三角形带。最终的图元会被光栅化，然后片段着色器会处理整个三角形带，最终在每个绘制的点处生成一个绿色房子：
    2.注意gs_in[]的生成
    在这里插入图片描述
#version 330 core
layout (points) in;
layout (triangle_strip, max_vertices = 5) out;	//5个点

//用接口块接收

in VS_OUT{
	vec3 color;
}gs_in[];
	
out vec3 fColor; 
 
//生成函数
void build_house(vec4 position)
{    
	fColor=gs_in[0].color;  
    gl_Position = position + vec4(-0.2, -0.2, 0.0, 0.0);    // 1:左下
    EmitVertex();   
    gl_Position = position + vec4( 0.2, -0.2, 0.0, 0.0);    // 2:右下
    EmitVertex();
    gl_Position = position + vec4(-0.2,  0.2, 0.0, 0.0);    // 3:左上
    EmitVertex();
    gl_Position = position + vec4( 0.2,  0.2, 0.0, 0.0);    // 4:右上
    EmitVertex();
    gl_Position = position + vec4( 0.0,  0.4, 0.0, 0.0);    // 5:顶部
	fColor=vec3(1.0,1.0,1.0);	//将顶点设置为白色
    EmitVertex();	
    EndPrimitive(); //输出图源
}
void main() {    
    build_house(gl_in[0].gl_Position);
}

  • 主程序

     定义着色器

    Shader geoShader("geometry_shader.vert", "geometry_shader.frag", "geometry_shader.glsl");

定义顶点位置和生成vao，vbo放到while循环外

    //几何着色器用到的代码
    //画4个房子：X,Y坐标，RGB三个颜色参数
    float points[] = {
    -0.5f,  0.5f, 1.0f, 0.0f, 0.0f, // top-left
     0.5f,  0.5f, 0.0f, 1.0f, 0.0f, // top-right
     0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // bottom-right
    -0.5f, -0.5f, 1.0f, 1.0f, 0.0f  // bottom-left
    };
    unsigned int VBO, VAO;
    glGenBuffers(1, &VBO);
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(points), &points, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);	//在VAO中传递位置值
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0);
    glEnableVertexAttribArray(1);	//在VAO中传递颜色值
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(2 * sizeof(float)));
    glBindVertexArray(0);

 - 绘画

        // draw points
        geoShader.useShader();
        glBindVertexArray(VAO);
        glDrawArrays(GL_POINTS, 0, 4);
  • 注：在几何着色器中如果要修改大小要用
gl_PotionSize = 16;
  • 结果:
    在这里插入图片描述
略略鱼子酱
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【OpenGL实践10】关于几何着色器
gongdiwudu的专栏
05-21 938
几何着色器的应用比较高级，关于几何着色器使用究竟需要什么样的步骤，几何着色器能解决什么样的问题。需要示范案例，本文将演示这个过程。
OpenGL之几何着色器(Geometry Shader)详解
What_can_you_do的博客
12-12 1977
OpenGL学习笔记
计算机图形学：绘制一个3d交互场景（1）
weixin_52049271的博客
12-14 4799
使用OpenGL搭建一个三维场景，能够通过输入设备与场景内物体交互。glMaterialfv ()函数指定照明模型的材料参数。配置环境：vs22+freeglut库。场景先写到这儿吧，其他物品随意可加的，完整源码评论区留邮箱。
openGL学习—Layout
最新发布
qq_75066978的博客
04-27 375
通过在OpenGL代码中使用glGetAttribLocation 查询属性位置值（Location）或。顶点着色器接收的是特殊形式的输入，从顶点数据中直接接收输入。为了定义顶点数据如何管理，使用loaction指定输入变量。glBindAttriblocation查询属性。layout标识可以将其连接到顶点数据。
OpenGL学习之着色器详解
Estelle
06-23 2614
OpenGL着色器语言（GLSL）看上去很像C语言，它由OpenGL实现进行编译和连接，并且（经常是）完全在图形硬件中运行。 我们有顶点着色器、片段着色器和几何着色器，前两种是必需的，后一种是可选的。 有三种向顶点着色器传递数据的方式：（1）参数，是对每个顶点而言； （2）统一值，是针对整个顶点数据批次的常量（所以是一致的） （3）加载和使用纹理数据 可以为片段着色器设置统一值和纹理数据...
OpenGL总结15-光照模型
windxgz的博客
08-17 1041
光照模型 绘制地形图时发现图像看不出起伏，觉得应该是关照模型和法线的问题，所以查找了一些资料，这里做一个总结。 在查看计算机图形学的时候，书中提到光照模型与表面绘制，为了避免属于混乱，定义了光照模型和表面绘制的定义。 光照模型：对单个点进行光照计算的模型 表面绘制：利用光照模型获得投影中所有表面像素颜色 物体的表面光照一般包括反射、透明、纹理、阴影。一般采用物理模型对光照的显示进行模拟。 光源分类 点光源：通过RGB颜色值指定的单色光点，通过位置和颜色定义。一般用于距离较远的场景（包括距离以及相对物体
Opengl着色器播放器
05-25
此外，还有几何着色器、 tessellation着色器等，它们分别在不同的图形处理阶段发挥作用，增加图形的细节和复杂性。 3. **MFC（Microsoft Foundation Classes）**：MFC是微软提供的C++类库，它简化了Windows应用程序...
OpenGL着色器语言全集(橙皮书).zip
08-14
6. **高级主题**：可能涉及几何着色器、Tessellation着色器和计算着色器，这些都是OpenGL 4.x及更高版本引入的新特性，用于实现复杂的几何生成和离屏渲染。 7. **实例与项目**：提供实际的代码示例和项目，帮助学习...
opengl入门 绘制三角形+片段着色器
10-12
OpenGL入门教程：绘制三角形与使用片段着色器 在计算机图形学的世界里，OpenGL是一个广泛使用的跨语言、跨平台的编程接口，用于渲染2D、3D矢量图形。本教程将指导初学者如何使用OpenGL，特别是通过Visual Studio ...
几何着色器
12-04
在计算机图形学领域，几何着色器（Geometry Shader）是OpenGL着色器语言（GLSL）中的一个重要组件，用于处理图形管线中的几何阶段。本文将深入探讨几何着色器的概念、工作原理以及如何在OpenGL环境下应用它。 首先...
OpenGL ES着色器使用详解（二）
01-20
在OpenGL ES中，着色器是图形渲染的核心部分，它们负责计算每个像素或顶点的颜色、位置以及其他属性。本文主要探讨了着色器语言的使用，包括数据类型、向量和矩阵的操作，以及采样器和数组的使用。 1. **着色器语言...
用VC opengl 绘制的一个房屋轮廓
12-17
用VC opengl 绘制的一个房屋轮廓
opengl画的小花
04-14
实验源代码，opengl画花的源程序，可随机生成许多花，一屏，颜色也是随机的
hw7_opengl_opengl房子_材质包_小房子_
10-01
用opengl绘制的带材质小房子，带小院子和狗屋
【OpenGL】十九、OpenGL 绘制模式 ( 绘制线框模式 绘制点模式 ).zip
01-20
【OpenGL】十九、OpenGL 绘制模式 ( 绘制线框模式 | 绘制点模式 ) https://hanshuliang.blog.csdn.net/article/details/112858006 ( 该源码是 Windows 桌面程序 , 使用 Visual Studio 2019 打开 )
opengl房子
04-15
利用opengl，vc++编写的一个纹理贴图例子。
计算机图形学OpenGL实验——实现三维空间、视野方向转换
weixin_43576525的博客
02-29 9457
计算机图形学实验，用OpenGL实现三维空间，绘制三维房间、家具、房屋建筑等。 用到的OpenGL 函数 glColor3f(blue); //设置颜色 glutSolidCube(size);//绘制正方体 glVertex3f(x, y, z);//设置点坐标 glLightfv(a,b,c); //设置光源 glTranslatef(x, y, z`)`;//平移函数 gl...
几何着色器（一） 基本概念
wk_119的博客
05-18 7889
最近想做一些渲染的东西，接触到了几何着色器，发现了几何着色器的强大之处，几何着色器位于顶点和片元着色器之间，几何着色器能够产生0个以上的基础图元，它能起到一定的裁剪作用、同时也能产生比顶点着色器输入更多的基础图元。 它可以做的事情非常的酷炫，例如：表面法线的可视化和实现三维物体的爆炸效果。   基本知识：   输入可以有如下： points：绘制GL_POINTS图元时。 lines...
OpenGL编程：GLSL着色器与纹理应用详解
在OpenGL编程中，GLSL（OpenGL Shading Language）是一种强大的工具，用于定义自定义的着色器，为图形渲染增加更多的细节和复杂性。在GLSL中，纹理是一种重要的概念，它们允许我们通过2D图像（以及1D和3D纹理）来给...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值