OpenGL 几何着色器 传入点,绘制三角形

最新推荐文章于 2024-08-15 11:29:55 发布
最新推荐文章于 2024-08-15 11:29:55 发布
阅读量2.1k 收藏 6
点赞数
分类专栏： OpenGL 文章标签： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulinxx/article/details/59538755
版权

几何着色器有意思的地方在于它可以把（一个或多个）顶点转变为完全不同的基本图形（primitive），从而生成比原来多得多的顶点。

这里写图片描述

main.cpp

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

#include <GLFW/glfw3.h>

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

#include <SOIL/SOIL.h>

#include "Shader.h"

#pragma comment(lib, "SOIL.lib")

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glew32s.lib")
#pragma comment (lib, "glfw3.lib") 
#pragma comment (lib, "glfw3dll.lib") 
#pragma comment (lib, "glew32mxs.lib")
#pragma comment (lib, "assimp.lib")

#define  WIDTH 800
#define  HEIGH 600

int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* pWnd = glfwCreateWindow(WIDTH, HEIGH, "OGL Geometry Shader", nullptr, nullptr);
    glfwMakeContextCurrent(pWnd);

    glewExperimental = GL_TRUE;

    glewInit();

    glViewport(0, 0, WIDTH, HEIGH);

    GLfloat fPoint[] = {
        0.0f, 0.0f, 0.0f,       0.4f, 0.3f, 0.0f,
        0.5f, -0.6f, 0.0f,      0.0f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.0f,       0.0f, 0.0f, 1.0f,
        -0.5f, 0.6f, 0.0f,      0.0f, 1.0f, 1.0f,
        -0.2f, -0.5f, 0.0f, 0.0f, 0.4f, 1.0f,
        - 0.8f, 0.3f, 0.0f,     1.0f, 0.30f, 1.0f
    };

    GLuint nVAO, nVBO;
    glGenVertexArrays(1, &nVAO);
    glBindVertexArray(nVAO);
    {
        glGenBuffers(1, &nVBO);
        glBindBuffer(GL_ARRAY_BUFFER, nVBO);
        {
            glBufferData(GL_ARRAY_BUFFER, sizeof(fPoint), fPoint, GL_STATIC_DRAW);

            glEnableVertexAttribArray(0);   // vertex
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6* sizeof(GLfloat), (GLvoid*)0);

            glEnableVertexAttribArray(1);   // color
            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6* sizeof(GLfloat), (GLvoid*)(3 * sizeof(GL_FLOAT)));
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
    glBindVertexArray(0);

    glEnable(GL_PROGRAM_POINT_SIZE);

    Shader shader("./Shader/vertex.vx", "./Shader/geo.geo", "./Shader/frag.fg");
    //Shader shader("./Shader/vertex.vx", "./Shader/frag.fg");
    shader.userShaderProg();

    while (!glfwWindowShouldClose(pWnd))
    {
        glfwPollEvents();

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glBindVertexArray(nVAO);
        {
            //glDrawArrays(GL_TRIANGLES, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
            glDrawArrays(GL_POINTS, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
            //glDrawArrays(GL_LINE_STRIP, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
        }
        glBindVertexArray(0);

        glfwSwapBuffers(pWnd);
    }

    return 0;
}

Shader

#pragma once

#include <glew.h>

class Shader
{
public:
    Shader(const GLchar* pVertexPath, const GLchar* pFragPath);
    Shader(const GLchar* pVertexPath, const GLchar* pGeomPath, const GLchar* pFragPath);
    ~Shader();

public:
    void userShaderProg();

    GLuint getProg();

private:
    void initShader(const GLchar* pVertexPath, const GLchar* pFragPath);
    void initShader(const GLchar* pVertexPath, const GLchar* pGeomPath, const GLchar* pFragPath);

private:
    GLuint m_nProg;
};


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

#include "Shader.h"


Shader::Shader(const GLchar* pVertexPath, const GLchar* pFragPath)
{
    initShader(pVertexPath, pFragPath);
}


Shader::Shader(const GLchar* pVertexPath, const GLchar* pGeomPath, const GLchar* pFragPath)
{
    initShader(pVertexPath, pGeomPath, pFragPath);
}


Shader::~Shader()
{
    glDeleteProgram(m_nProg);
}


void Shader::userShaderProg()
{
    glUseProgram(m_nProg);
}


GLuint Shader::getProg()
{
    return m_nProg;
}


void Shader::initShader(const GLchar* pVertexPath, const GLchar* pFragPath)
{
    std::string strVertexCode;
    std::string strFragCode;

    std::ifstream sVertexShaderF;
    std::ifstream sFragShaderF;

    sVertexShaderF.exceptions(std::ifstream::badbit);
    sFragShaderF.exceptions(std::ifstream::badbit);

    try
    {
        sVertexShaderF.open(pVertexPath);
        sFragShaderF.open(pFragPath);

        std::stringstream sVertexShaderStream, sGeomShaderStream, sFragShaderStream;
        sVertexShaderStream << sVertexShaderF.rdbuf();
        sFragShaderStream << sFragShaderF.rdbuf();
        sVertexShaderF.close();
        sFragShaderF.close();

        strVertexCode = sVertexShaderStream.str();
        strFragCode = sFragShaderStream.str();
    }
    catch (const std::exception& e)
    {
        std::cout << "ERROR ON std::exception" << e.what() << std::endl;
    }
    catch (const std::ifstream& e)
    {
        std::cout << "ERROR ON td::ifstream&" << e.rdbuf() << std::endl;
    }

    const GLchar* pChVertexCode = strVertexCode.c_str();
    const GLchar* pChFragCode = strFragCode.c_str();

    GLuint nVertexShader, nGeomShader, nFragShader;
    GLint nRes = 0;
    GLchar chLogInfo[512] = { '\0' };

    // Create Vertex Shader Program
    nVertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(nVertexShader, 1, &pChVertexCode, nullptr);
    glCompileShader(nVertexShader);

    glGetShaderiv(nVertexShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nVertexShader, 512, nullptr, chLogInfo);
        std::cout << "ERORR ON VERTES SHADER:" << chLogInfo << std::endl;
    }

    // Create Fragement Shader Program
    nFragShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(nFragShader, 1, &pChFragCode, nullptr);
    glCompileShader(nFragShader);
    glGetShaderiv(nFragShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nFragShader, 512, nullptr, chLogInfo);
        std::cout << "ERROR ON FRAGMENT SHADER:" << chLogInfo << std::endl;
    }

    // Create Shader Programe
    m_nProg = glCreateProgram();
    glAttachShader(m_nProg, nVertexShader);
    glAttachShader(m_nProg, nFragShader);

    glLinkProgram(m_nProg);
    glGetProgramiv(m_nProg, GL_LINK_STATUS, &nRes);
    if (!nRes)
    {
        glGetProgramInfoLog(m_nProg, 512, nullptr, chLogInfo);
        std::cout << "ERROR ON PROGRAME:" << chLogInfo << std::endl;
    }

    glDeleteShader(nVertexShader);
    glDeleteShader(nFragShader);
}


void Shader::initShader(const GLchar* pVertexPath, const GLchar* pGeomPath, const GLchar* pFragPath)
{
    std::string strVertexCode;
    std::string strGeomCode;
    std::string strFragCode;

    std::ifstream sVertexShaderF;
    std::ifstream sGeomShaderF;
    std::ifstream sFragShaderF;

    sVertexShaderF.exceptions(std::ifstream::badbit);
    sGeomShaderF.exceptions(std::ifstream::badbit);
    sFragShaderF.exceptions(std::ifstream::badbit);

    try
    {
        sVertexShaderF.open(pVertexPath);
        sGeomShaderF.open(pGeomPath);
        sFragShaderF.open(pFragPath);

        std::stringstream sVertexShaderStream, sGeomShaderStream, sFragShaderStream;
        sVertexShaderStream << sVertexShaderF.rdbuf();
        sGeomShaderStream << sGeomShaderF.rdbuf();
        sFragShaderStream << sFragShaderF.rdbuf();
        sVertexShaderF.close();
        sGeomShaderF.close();
        sFragShaderF.close();

        strVertexCode = sVertexShaderStream.str();
        strGeomCode = sGeomShaderStream.str();
        strFragCode = sFragShaderStream.str();
    }
    catch (const std::exception& e)
    {
        std::cout << "ERROR ON std::exception" << e.what() << std::endl;
    }
    catch (const std::ifstream& e)
    {
        std::cout << "ERROR ON td::ifstream&" << e.rdbuf() << std::endl;
    }

    const GLchar* pChVertexCode = strVertexCode.c_str();
    const GLchar* pChGeomCode = strGeomCode.c_str();
    const GLchar* pChFragCode = strFragCode.c_str();

    GLuint nVertexShader, nGeomShader, nFragShader;
    GLint nRes = 0;
    GLchar chLogInfo[512] = { '\0' };

    // Create Vertex Shader Program
    nVertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(nVertexShader, 1, &pChVertexCode, nullptr);
    glCompileShader(nVertexShader);

    glGetShaderiv(nVertexShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nVertexShader, 512, nullptr, chLogInfo);
        std::cout << "ERORR ON VERTES SHADER:" << chLogInfo << std::endl;
    }

    // Create Geometry Shader Program
    nGeomShader = glCreateShader(GL_GEOMETRY_SHADER);
    glShaderSource(nGeomShader, 1, &pChGeomCode, nullptr);
    glCompileShader(nGeomShader);

    glGetShaderiv(nGeomShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nGeomShader, 512, nullptr, chLogInfo);
        std::cout << "ERORR ON GEOMETRY SHADER:" << chLogInfo << std::endl;
    }

    // Create Fragement Shader Program
    nFragShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(nFragShader, 1, &pChFragCode, nullptr);
    glCompileShader(nFragShader);
    glGetShaderiv(nFragShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nFragShader, 512, nullptr, chLogInfo);
        std::cout << "ERROR ON FRAGMENT SHADER:" << chLogInfo << std::endl;
    }

    // Create Shader Programe
    m_nProg = glCreateProgram();
    glAttachShader(m_nProg, nVertexShader);
    glAttachShader(m_nProg, nGeomShader);
    glAttachShader(m_nProg, nFragShader);

    glLinkProgram(m_nProg);
    glGetProgramiv(m_nProg, GL_LINK_STATUS, &nRes);
    if (!nRes)
    {
        glGetProgramInfoLog(m_nProg, 512, nullptr, chLogInfo);
        std::cout << "ERROR ON PROGRAME:" << chLogInfo << std::endl;
    }

    glDeleteShader(nVertexShader);
    glDeleteShader(nGeomShader);
    glDeleteShader(nFragShader);
}

GLSL

vertex.vx

#version 330 core

layout (location = 0) in vec3 pos;
layout (location = 1) in vec3 inColor;

out VS_OUT {
    vec3 color;
} outColor;


void main()
{
    gl_PointSize = 6;
    gl_Position = vec4(pos, 1.0f);

    outColor.color = inColor;
}

geo.geo

#version 330 core

layout (points) in;

layout (triangle_strip, max_vertices = 6) out;


in VS_OUT {
    vec3 color;
} inColor[];


out VS_OUT {
    vec3 color;
} outColor;

void main()
{
    outColor.color = inColor[0].color;

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

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

    gl_Position = gl_in[0].gl_Position + vec4(0.3, -0.2, 0.0, 0.0);
    EmitVertex();

    EndPrimitive();
}

frag.fg

#version 330  core

in VS_OUT {
    vec3 color;
} inColor;

out vec4 color;

void main()
{
    color = vec4(inColor.color, 1.0f);
}

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

加入视图功能:
3D图形的表示要经过几个经典的坐标转换，首先从局部到世界坐标系，再从世界坐标系到观察坐标系。
局部坐标系—>世界坐标系—>观察坐标系

顶点着色器中:
//gl_Position = vec4(pos, 1.0f);
gl_Position = projection * view * model * vec4(pos, 1.0f);

main.cpp 中

glm::mat4 view;
    view = glm::translate(view, glm::vec3(0.f, 1.0f, 0.0f));

    glm::mat4 proj;
    proj = glm::perspective(45.0f, 1.0f, 0.1f, 100.0f);

    glm::mat4 model;
    model = glm::translate(model, glm::vec3(0.0f, 0.0f, -5.0f));

    GLint nModelLoc = glGetUniformLocation(shader.getProg(), "model");
    GLint nViewLoc = glGetUniformLocation(shader.getProg(), "view");
    GLint nProjLoc = glGetUniformLocation(shader.getProg(), "projection");

    glUniformMatrix4fv(nModelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glUniformMatrix4fv(nViewLoc, 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(nProjLoc, 1, GL_FALSE, glm::value_ptr(proj));

源码下载:

http://download.csdn.net/detail/yulinxx/9769051

cmake.EXE
关注
专栏目录
OpenGL几何着色器
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-21 252
OpenGL几何着色器先上图，再解答。完整主要的源代码源代码剖析 先上图，再解答。 完整主要的源代码 #include <stdio.h> #include "GL/glus.h" static GLUSprogram g_program; static GLint g_projectionMatrixLocation; static GLint g_viewMatrixLocation; static GLint g_normalMatrixLocation; static GLint g_
OpenGL几何着色器(geometry shader)
【黑键】
02-03 852
OpenGL几何着色器(geometry shader) 除了顶点着色器(vertex shader)和片元着色器(fragment shader). OpenGL还提供了一个可选的几何着色器(geometry shader). 其位于顶点着色器和几何着色器之间. 如没有使用几何着色器,则顶点着色器输出到片元着色器. 若使用几何着色器,顶点着色器输出组成一个基础图元的顶点信息到几何着色器,经过几...
opengl几何着色器
LIEY
05-25 256
几何着色器的输入是一个图元（如点或三角形）的一组顶点。几何着色器可以在顶点发送到下一着色器阶段之前对它们随意变换。然而，几何着色器最有趣的地方在于，它能够将（这一组）顶点变换为完全不同的图元，并且还能生成比原来更多的顶点。 #version 330 core layout (points) in; layout (line_strip, max_vertices = 2) out; void main() { gl_Position = gl_in[0].gl_Position + vec
LearnOpenGL——几何着色器、实例化
最新发布
weixin_70073176的博客
08-15 960
在顶点着色器和片元着色器之间还有一个可选的几何着色器，几何着色器输入的是一个图元（点或者三角形）的一组顶点，几何着色器可以在片元着色器之前对它们进行随意变化，可以变换为不同的图元，也可以生成更多的顶点。我们需要声明从顶点着色器输入的图元类型——在in前面加一个布局修饰符（如下），如果我们要绘制三角形，就将修饰符修改为triangles，括号内的数字表示的是一个图元所包含的最小顶点数。几何着色器，会接收每一个顶点（包括一个位置向量和一个法向量），并在每个位置向量处绘制一个法线向量。
【OpenGL原理】顶点着色器、片元着色器、几何着色器
gongdiwudu的专栏
03-15 2840
我们除了对GLSL语言本身的理解，对真正的宏观管线认知是越早越好的事情。理解着色器的能力，以及使用局限性能够迫使我们修正设计思路。也许我们胸中有无限多的想象，一旦面对着色器的无能为力，精妙想向也就灰飞叶湮灭。有时需要引进其它的环节，但又不能确定是否用着色器本身就能完成？种种困局需要我们扎实理解渲染管线和着色器原理，然后才能决定采取何种技术路线。
OpenGL进阶之几何着色器
qq_44800780的博客
10-07 340
参考： https://learnopenglcn.github.io/04%20Advanced%20OpenGL/09%20Geometry%20Shader/ 几何着色器的输入是一个图元（如点或三角形）的一组顶点。几何着色器可以在顶点发送到下一着色器阶段之前对它们随意变换。 然而，几何着色器最有趣的地方在于，它能够将（这一组）顶点变换为完全不同的图元，并且还能生成比原来更多的顶点。 直接先看...
OpenGL ES for Android（几何着色器）
1
05-27 535
简介 几何着色器(Geometry Shader)是一个可选功能，他介于在顶点和片段着色器之间，接收一组顶点数据，可以对数据进行处理，而且可以根据数据生成不止一个图形，假如你想绘制四个顶点，按照以前的方式，需要for循环四次，每次都顶点数据进行处理，最后传入顶点着色器中。而集合着色器就做了这样一件事。在移动平台上，几何着色器需要OpenGL ES 3.2版本（android 7之上），同样的我们可以先参考文档或其他相关资料学习3.0新特性。 3.0变化 这里简单学习一下3.0和2.0比较重要的变化
OpenGL几何着色器(1)
weixin_38498942的博客
10-23 246
一、简介 在顶点和片段着色器之间有一个可选的着色器，叫做几何着色器(Geometry Shader)。几何着色器以一个或多个表示为一个单独基本图形（primitive）的顶点作为输入，比如可以是一个点或者三角形。几何着色器在将这些顶点发送到下一个着色阶段之前，可以将这些顶点转变为它认为合适的内容。几何着色器有意思的地方在于它可以把（一个或多个）顶点转变为完全不同的基本图形（primitive），从...
OpenGL Geometry Shader Tutorial（OpenGL几何着色器教程）
04-05
The OpenGL Geometry Shader Tutorial from Oregon State University，it's cool...
OpenGL基于着色器-Sierpinski3D镂垫（用点绘制）
06-05
用5000个点，实现Sierpinski3D镂垫，其中点的颜色根据点的坐标在顶点着色器中给定
opengl之几何着色器（爆破物体）
wqdqwass的博客
09-09 391
爆破物体 opengl官方文档之几何着色器 尽管绘制房子非常有趣，但我们不会经常这么做。这也是为什么我们接下来要继续深入，来爆破(Explode)物体！虽然这也是一个不怎么常用的东西，但是它能向你展示几何着色器的强大之处。 当我们说爆破一个物体时，我们并不是指要将宝贵的顶点集给炸掉，我们是要将每个三角形沿着法向量的方向移动一小段时间。效果就是，整个物体看起来像是沿着每个三角形的法线向量爆炸一样。爆炸三角形的效果在纳米装模型上看起来像是这样的： 因为每一个点的法线值和面的法线值是不一样的，所以我们要自
Ｏｐｅｎｇｌ画三角形
每日三省吾身，按时吃饭否 按时睡觉否 按时喝水否
07-04 1681
ｏｐｅｎｇｌ
OpenGL学习笔记：几何着色器
热门推荐
mumufan05的专栏
09-19 1万+
之前还有一节介绍高级数据处理的，和这节的几何着色器都很好理解，没啥可总结的，直接上例子代码 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <stb_image.h> #include <glm/glm.hpp> #include <glm/gtc/matrix_transfo...
OpenGL 几何着色器 Geometry Shader 初探
...
12-26 1869
在顶点和片段着色器之间有一个可选的着色器，叫做几何着色器(Geometry Shader)。几何着色器以一个或多个表示为一个单独基本图形（primitive）的顶点作为输入，比如可以是一个点或者三角形。几何着色器在将这些顶点发送到下一个着色阶段之前，可以将这些顶点转变为它认为合适的内容。几何着色器有意思的地方在于它可以把（一个或多个）顶点转变为完全不同的基本图形（primitive），从而生成比原来多得多的顶点。
LearnOpenGL学习笔记——OpenGL绘制三角形
VIPCCJ的博客
09-03 530
绘制三角形 绘制三角形之前：需要理解一下几件事情 1.顶点输入 顶点数组对象：Vertex Array Object，VAO 顶点缓冲对象：Vertex Buffer Object，VBO 索引缓冲对象：Element Buffer Object，EBO或Index Buffer Object，IBO 为什么使用VAO和VBO. 请看以下代码，opengl渲染一堆数据的时候，我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的
OpenGl体验几何着色器
webgpu
07-13 332
首先需要有带法线的模型  learnOpenGL里面的shader("vert","frag","geomery"); shader跟顶点着色器和片段着色器写法差不多然后进入顶点着色器out VS_OUT{vec3 normal;}vs_out;aNormal是读进来的layout需要一个矩阵m来纠正法线mat3(transpose(inverse(view*model)));vs_out.nor...
OpenGL之几何着色器(Geometry Shader)详解
What_can_you_do的博客
12-12 2077
OpenGL学习笔记
opengl几何着色器步骤
10-04
OpenGL几何着色器（Geometry Shader）的步骤如下： 1. 创建几何着色器对象：使用glCreateShader函数创建一个几何着色器对象，并将其类型设置为GL_GEOMETRY_SHADER。 2. 编译几何着色器源码：使用glShaderSource函数将几何着色器源码绑定到几何着色器对象上，然后使用glCompileShader函数编译几何着色器。 3. 检查编译错误：可以使用glGetShaderiv函数获取编译状态，检查是否编译成功。如果编译失败，可以使用glGetShaderInfoLog函数获取错误日志信息。 4. 创建程序对象并附加几何着色器：使用glCreateProgram函数创建一个程序对象，并使用glAttachShader函数将几何着色器对象附加到程序对象上。 5. 链接程序对象：使用glLinkProgram函数链接程序对象。 6. 检查链接错误：可以使用glGetProgramiv函数获取链接状态，检查是否链接成功。如果链接失败，可以使用glGetProgramInfoLog函数获取错误日志信息。 7. 使用程序对象：使用glUseProgram函数激活程序对象，使其成为当前的着色器程序。 8. 设置几何着色器输入和输出：通过glProgramParameteri函数设置几何着色器的输入和输出类型和数量。 9. 绘制图元：通过调用绘制函数如glDrawArrays或glDrawElements来执行几何着色器中定义的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值