OpenGL 学习笔记--矩阵变换(07)

最新推荐文章于 2024-05-31 17:10:38 发布
最新推荐文章于 2024-05-31 17:10:38 发布
阅读量386 收藏 1
点赞数 1
分类专栏： OpenGL学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NiMiKiss/article/details/108763194
版权

矩阵变换

Notes

  • glm矩阵变换
    矩阵相乘顺序 trans * scale * translate * rotate
    模型作用顺序 rotate->translate->scale
glm::mat4 trans;
trans = glm::scale(trans, glm::vec3(0.5, 0.5, 0.5));
trans = glm::translate(trans, glm::vec3(1.0f, 1.0f, 0.0f));
trans = glm::rotate(trans, glm::radians(90.0f), glm::vec3(0.0, 0.0, 1.0));

const char* vertexShaderSource = "#version 400 core\n"
"layout (location = 0) in vec3 aPos;\n"
"layout (location = 1) in vec2 aTexCoord;\n"
"out vec2 TexCoord;\n"
"uniform mat4 transform;\n"
"void main()\n"
"{\n"
"   gl_Position =transform * vec4(aPos.x, aPos.y, aPos.z, 1.0f);\n"
"   TexCoord = aTexCoord;\n"
"}\0";

输出结果
在这里插入图片描述

  • 坐标系统
    局部坐标系相对于局部原点坐标
    世界坐标系想对于世界的全局原点
    观察坐标相对于相机
    裁剪坐标，裁剪坐标处理至[-1,1]范围内
    屏幕坐标，裁剪坐标转换为屏幕坐标
    在这里插入图片描述
  • 局部坐标系->世界坐标系(Model矩阵)，cubePositions为立方体在世界坐标位置，进行平移和自旋转
model = glm::translate(model, glm::vec3(cubePositions[i]));
model = glm::rotate(model, float(glfwGetTime()), glm::vec3(1.0f, 2.0f, 0.0f));
  • 世界坐标系->观察空间坐标(View矩阵)，相机位置(0.0f, 0.0f, 3.0f)，立方体整体沿z轴平移((0.0f, 0.0f, -3.0f))
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
  • 观察空间坐标->裁剪空间坐标(Projection矩阵)

    • 透视投影(距离越远，看到的东西更小，w可看作另一个维度，坐标范围都在[-w,w]，FOV视角内)
      projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);
      在这里插入图片描述

    • 正视投影(定义了一个类似立方体的平截头箱，坐标范围都在这个空间之内
      glm::ortho(0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f);
      在这里插入图片描述

  • 裁剪空间坐标->屏幕坐标(ViewportTransform矩阵)
  • 将转换矩阵通过uniform的方式给到顶点着色器，计算坐标点位置
glUniformMatrix4fv(glGetUniformLocation(shader.GetShaderProgramID(), "transform"),
				1, GL_FALSE, glm::value_ptr(trans));
				
const char* vertexShaderSource = "#version 400 core\n"
		"layout (location = 0) in vec3 aPos;\n"
		"layout (location = 1) in vec2 aTexCoord;\n"
		"out vec2 TexCoord;\n"
		"uniform mat4 transform;\n"
		"void main()\n"
		"{\n"
		"   gl_Position =transform * vec4(aPos.x, aPos.y, aPos.z, 1.0f);\n"
		"   TexCoord = aTexCoord;\n"
		"}\0";
  • 开启深度测试
    OpenGL存储它的所有深度信息于一个z缓冲(Z-buffer)中，也称为深度缓冲(Depth Buffer)。深度值存储在每个片段里面(作为片段的z值)，当片段想要输出它的颜色时，OpenGL会将它的深度值和Z缓冲进行比较，如果当前片段在其它片段之后，它将会被丢弃，否则将会覆盖。
    每次渲染迭代之前清除深度缓冲（否则前一帧的深度信息仍然保存在缓冲中）
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

代码示例

https://gitee.com/NiMiKiss/opengl-notes.git
shader.h

#ifndef _SHADER_H_
#define _SHADER_H_
#include<glad/glad.h>
#include<GLFW/glfw3.h>
#include <iostream>
class Shader
{
public:
	Shader();
	~Shader();
	void UseShader() const;
	void InitShader();
	int GetShaderProgramID() const;
private:
	int m_iShaderProgramID;
};

#endif // !_SHADER_H_

shader.cpp

#include "Shader.h"

Shader::Shader()
{

}

Shader::~Shader()
{

}

void Shader::InitShader()
{
	const char* vertexShaderSource = "#version 400 core\n"
		"layout (location = 0) in vec3 aPos;\n"
		"layout (location = 1) in vec2 aTexCoord;\n"
		"out vec2 TexCoord;\n"
		"uniform mat4 transform;\n"
		"void main()\n"
		"{\n"
		"   gl_Position =transform * vec4(aPos.x, aPos.y, aPos.z, 1.0f);\n"
		"   TexCoord = aTexCoord;\n"
		"}\0";
	const char* fragmentShaderSource = "#version 400 core\n"
		"out vec4 FragColor;\n"
		"in vec2 TexCoord;\n"
		"uniform sampler2D ourTexture1;\n"
		"uniform sampler2D ourTexture2;\n"
		"void main()\n"
		"{\n"
		"   FragColor = mix(texture(ourTexture1,TexCoord),texture(ourTexture2,TexCoord),0.2);\n"
		"}\n\0";

	int vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
	glCompileShader(vertexShader);

	int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
	glCompileShader(fragmentShader);

	m_iShaderProgramID = glCreateProgram();
	glAttachShader(m_iShaderProgramID, vertexShader);
	glAttachShader(m_iShaderProgramID, fragmentShader);
	glLinkProgram(m_iShaderProgramID);
}

void Shader::UseShader() const
{
	glUseProgram(m_iShaderProgramID);
}

int Shader::GetShaderProgramID()const
{
	return m_iShaderProgramID;
}

OpenGL.cpp

#include "Shader.h"
#include "stb_image.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

Shader shader;
GLFWwindow* window;
unsigned int VAO;
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

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

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

void Init()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
	if (window == NULL)
	{
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return;
	}
	glfwMakeContextCurrent(window);

	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return;
	}

	shader.InitShader();
}

void SetVAO()
{
	unsigned int VBO, EBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);

	glBindVertexArray(VAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));

	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
}

void Texture()
{
	int width(0), height(0), nrChannels(0);
	unsigned char* data;
	stbi_set_flip_vertically_on_load(true);
	unsigned int texture[2];
	glGenTextures(2, texture);

	glBindTexture(GL_TEXTURE_2D, texture[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	data = stbi_load("../OpenGL/resources/textures/container.jpg", &width, &height, &nrChannels, 0);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
	glGenerateMipmap(GL_TEXTURE_2D);
	stbi_image_free(data);

	glBindTexture(GL_TEXTURE_2D, texture[1]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	data = stbi_load("../OpenGL/resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
	glGenerateMipmap(GL_TEXTURE_2D);
	stbi_image_free(data);

	glActiveTexture(GL_TEXTURE0); //先激活再绑定
	glBindTexture(GL_TEXTURE_2D, texture[0]);

	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, texture[1]);
	shader.UseShader();
	glUniform1i(glGetUniformLocation(shader.GetShaderProgramID(), "ourTexture1"), 0);
	glUniform1i(glGetUniformLocation(shader.GetShaderProgramID(), "ourTexture2"), 1);
}
int main()
{
	Init();
	SetVAO();
	Texture();

	glEnable(GL_DEPTH_TEST);
	while (!glfwWindowShouldClose(window))
	{
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		for (size_t i = 0; i < 10; ++i)
		{
			glm::mat4 trans(glm::mat4(1.0f)), model(glm::mat4(1.0f)), view(glm::mat4(1.0f)), projection(glm::mat4(1.0f));

			model = glm::translate(model, glm::vec3(cubePositions[i]));
			model = glm::rotate(model, float(glfwGetTime()), glm::vec3(1.0f, 2.0f, 0.0f));
			
			view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));

			projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);

			trans = projection * view * model;

			glUniformMatrix4fv(glGetUniformLocation(shader.GetShaderProgramID(), "transform"),
				1, GL_FALSE, glm::value_ptr(trans));

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

		glfwSwapBuffers(window);
		glfwPollEvents();
	}
}

输出结果
10个旋转的立方体
在这里插入图片描述

阿狸灬小丸子
关注
专栏目录
OpenGL之矩阵相乘
正在注销账号的博客
07-16 1024
单位矩阵 主对角线上数据都是1，其余元素都是0，即为单元矩阵。 向量 X 单元矩阵 = 向量 X 1，不会发生任何变化。 向量与单元矩阵相乘的前提是：向量的列数 == 单元矩阵的行数 矩阵分类 行优先矩阵： 一行一行读取。 列优先矩阵： 一列一列读取 两者的关系 行优先矩阵经过转置 即可的到列优先矩阵 矩阵的点乘 矩阵可以进行点乘的前提：两个矩阵的行列数相等 矩阵A · 矩阵B = 矩阵C -规则： 矩阵A的第一个元素与矩阵B的第一个元素的乘积 = 矩阵C的第一个元素 矩阵的叉乘 矩阵可以进行叉乘的前
OpenGL中的矩阵相乘的顺序
dizuo的专栏
04-24 1万+
1，在OpenGL中所有的视图变换，模型变换 都是4×4矩阵，每个后续的glMultiMatrix*(N),或者变换函数,glTranslate*(),glRotate*(),等都是把一个新的4×4矩阵与当前的矩阵M相乘，不同的是：变换函数glTranslate*(),glRotate*()等会根据函数参数构造一个4×4矩阵，也设为N，两种情况产生相同的结果：M×N。注意这里的顺序，后续的矩阵是右
矩阵及变换，以及矩阵在DirectX和OpenGL中的运用问题：左乘/右乘,行优先/列优先,...
baozi3026的专栏
10-20 7052
（一）首先，无论dx还是opengl，所表示的矢量和矩阵都是依据线性代数中的标准定义的： “矩阵A与B的乘积矩阵C的第i行第j列的元素c(ij)等于A的第i行于B的第j列的对应元素乘积的和。”（实用数学手册，科学出版社，第二版） 例如c12 = a11*b11+a12*b21+a12*b13... （二）在明确了这一点后，然后我们再看“矩阵的存储方式”，矩阵存储方式有两种，一种是“行主序
OpenGL 矩阵变换顺序与MVP矩阵变换
mozhi
12-24 6275
一、矩阵变换的顺序 对于一个坐标点，一般都是先缩放、后旋转、最后平移， 但是变换矩阵是和变量进行右乘的，所以要先计算平移矩阵、再旋转、再计算缩放。 这里重点讲述矩阵变换为什么一定要按照缩放、旋转、平移的顺序，不然就会出错。 矩阵变换的顺序解释参考：https://blog.csdn.net/pizi0475/article/details/9840921，这篇博客做了一些简单讲述，但是还不...
OpenGL-利用矩阵变换（缩放、旋转、位移），使用glm库
热门推荐
关注网络安全、云原生安全
04-15 1万+
目录 1. 矩阵知识总结 缩放 旋转 位移 2. glm使用方法 安装 使用 位移（使用translate函数） 旋转（使用rotate及radians函数） 缩放（使用scale函数） 在你的cpp中将变换矩阵传递给着色器 3.举个栗子 代码 截图 参考：LearnOpenGL 1. 矩阵知识总结 看下面内容之前请先恶补一下线性代数的知识，不对矩阵乘法等内容进行...
OpenGL学习笔记：矩阵变换
mumufan05的专栏
08-23 1万+
缩放 前面说了一大堆的理论，现在终于可以来点实际应用了 对一个向量进行缩放(Scaling)就是对向量的长度进行缩放，而保持它的方向不变。 我们先来尝试缩放向量v⃗=(3,2)\vec{v} =(3,2)v=(3,2)。我们可以把向量沿着x轴缩放0.5，使它的宽度缩小为原来的二分之一；我们将沿着y轴把向量的高度缩放为原来的两倍。我们看看把向量缩放(0.5, 2)倍所获得的s⃗\vec{s}s是什么...
【Android】OpenGL ES---图形变换
qq_42179419的博客
05-20 270
一、在OpenGL ES中，将一个3D模型显示到2D屏幕中有以下四个过程 1.视角（Viewing）变换 2.模型（Modeling）变换 3.投影（Projection）变换 4.视窗（Viewport）变换 二、视角（Viewing）变换和模型（Modeling）变换操作 这两者产生的效果是一样的，具体的有一下三种变换： -Translate 平移变换 -Rotate 旋转变换 -Scale 缩放变换 1.平移变换 在平移变换之前，调用一下代码 //设置单位矩阵 gl.
code__opengl学习笔记2-绘制矩形
09-24
在"code__opengl学习笔记1-基本的运行框架"中，可能包含了如何设置OpenGL环境、编译和运行程序的基础知识。这通常包括安装必要的库、配置编译器、创建项目结构以及理解GLUT的基本用法。这些都是进行OpenGL编程的先决...
Opengl笔记---坐标系统
你饿不饿
10-28 357
Opengl笔记---坐标系统
OpenGL 学习笔记(三) 基础变换
q1148811572的博客
11-21 364
一 向量 1.向量声明 gltool 库下的math3d库有俩个数据类型，能够表示一个三维或四维向量 声明一个三维向量 M3DVector3f 变量名={x,y,z} 声明一个四维向量 M3DVector4f 变量名={x,y,z,w} 第四个分量w 为缩放值 现在我们声明一个三分量顶点数组，生成一个三角行 声明一个三维向量 M3DVector3f 变量名[]={-0.5f,0.0f,0.0f
OpenGL里的矩阵堆栈（MVP的初始化以及后续更改M,V,P的操作）
qq_43274123的博客
03-11 801
openGL基础
Opengl实例7：glm(0.9.8.5)库 +矩阵旋转+课后作业
qq_38409301的博客
09-16 710
采用右向左读这个乘法。在组合矩阵时，先进行缩放操作，然后是旋转，最后才是位移，否则它们会（消极地）互相影响。比如，如果你先位移再缩放，位移的向量也会同样被缩放（译注：比如向某方向移动2米，2米也许会被缩放成1米）！链接：https://pan.baidu.com/s/1GsaewfRIDH5XnQSLweT93A?需要采用glm库进行矩阵的功能操作。y'=y*缩放*旋转*位移。位移*旋转*缩放*y =y。
齐次变换矩阵的旋转和平移顺序
qq292263211的博客
08-08 1690
先给出结论：齐次变换矩阵在进行坐标变换时，先进行旋转操作，再进行平移操作。可以看出先旋转时，旋转操作并不会影响旋转前的平移坐标。如果先平移再旋转的话，平移操作会改变旋转轴的坐标。
OpenGL-变换矩阵
神码编程
03-05 2717
OpenGL数学库glm 前面绘制了一个三角形，虽然比较简单，但我还是想让他有一些可设置的变化，于是这里就开始需要变换矩阵了。不过先抛掉一些枯燥乏味的理论知识，直接使用专门为OpenGl定制的glm库了，有了它，做个什么矩阵变换就轻轻松松，事半功倍了。 glm连接:http://glm.g-truc.net/0.9.5/index.html 将glm下载下来后放在自己引用的include的目...
OpenGL基础42：实例化
加载中...
08-04 629
一、循环渲染 在前面的场景里，箱子和地面都被渲染了多次： for (int i = 0; i <= 7; i++) { model = glm::translate(glm::mat4(1.0f), positions[i]); model = glm::scale(model, glm::vec3(0.01f)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); wood....
关于矩阵相乘顺序的理解（跟旋转没关）
empire_king的博客
05-08 4550
关于是由点乘矩阵，还是矩阵乘点，而导致的矩阵相乘顺序的理解（跟旋转没关），同时提出为什么大多数教材采用矩阵乘点这种方式的理解，和opengl采用列优先存储矩阵的理解
opengl中的矩阵和向量
小孔明的专栏
04-18 1186
如下代码： glm::mat4 sphereModel; sphereModel = glm::translate(sphereModel, glm::vec3(0, 0, -10.0f)); 输出： _cprintf("%f %f %f %f\n", sphereModel[0][0], sphereModel[1][0], sphereModel[2][0], sphereModel[3][0...
OpenGL 和 DirectX 矩阵 乘法 左乘和右乘，glm和DirectXMath。 OpenGL用列矩阵 在 glsl中反转矩阵
最新发布
cfl997
05-31 342
在OpenGL中，矩阵运算通常使用GLM（OpenGL Mathematics）库来进行。GLM库提供了与OpenGL兼容的数学运算功能，包括矩阵和向量的操作。而在DirectX中，矩阵运算通常使用DirectXMath库。GLM和DirectXMath都遵循列主序存储矩阵元素，但它们在矩阵乘法的顺序上有所不同：GLM使用的是行向量乘法，而DirectX使用的是列向量乘法。这导致了矩阵乘法的结果可能不同，具体取决于操作顺序。
【Modern OpenGL】转换 Transformations
aganlengzi的专栏
12-28 2398
我们已经学会了怎样创建对象，并且学会利用着色或者纹理使他们呈现出表面细节，但是它们还并不是十分有趣，因为它们只是静止的对象。我们虽然可以通过在每帧中改变它们的顶点坐标值挥着通过重新配置他们的缓存区使它们动起来，但是这样做是十分繁杂并且消耗更多能量。实际上，有更好的办法可以转换一个对象：使用一个矩阵对象。 矩阵是一种十分强大的数学概念，一开始看上去是令人生畏的。但是当你习惯它们的时候，你会觉得它们非常有用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值