OpenGL 学习（一）学习画三角形

最新推荐文章于 2022-09-02 13:12:52 发布
最新推荐文章于 2022-09-02 13:12:52 发布
阅读量300 收藏 2
点赞数
分类专栏： 计算机图形学 文章标签： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beijixingcd/article/details/104229650
版权

写在前面：最近闲来无事，学习OpenGL，在此记下代码，督促自己好好学习！

中文OpenGL学习网站：https://learnopengl-cn.github.io

一、画一个橘色的三角形

1.1代码

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

const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow* vWindow,int vWidth,int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow* vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,0.5f,0.2f,1.0f);\n"
"}\n\0";

int main()
{
	//配置glfw
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	//
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	//窗口回调函数，当窗口发生变化的时候回调callbackFramebufferSize函数
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	//初始化glad
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	//顶点着色器的编译
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexShaderSource, NULL);
	glCompileShader(VertexShader);
	//判断编译是否成功
	int Success;
	char InfoLog[512];
	glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(VertexShader, 512, NULL, InfoLog);
		std::cout << "error::shader::vertex::compilation failed\n" << InfoLog << std::endl;
	}
	//片段着色器的编译
	int FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader, 1, &FragmentShaderSource, NULL);
	glCompileShader(FragmentShader);
	glGetShaderiv(FragmentShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(FragmentShader, 512, NULL, InfoLog);
		std::cout << "error::shader::fragment::compilation failed\n" << InfoLog << std::endl;
	}
	//链接着色器程序
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_LINK_STATUS,&Success);
	if (!Success)
	{
		glGetProgramInfoLog(ShaderProgram, 512, NULL, InfoLog);
		std::cout << "error::shader::program::linking failed\n" << InfoLog << std::endl;
	}
	//删除着色器
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	float Vertices[] =
	{
		-0.5f,-0.5f,0.0f,
		0.5f,-0.5f,0.0f,
		0.0f,0.5f,0.0f
	};
	unsigned int VBO, VAO;
	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, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
        //开始渲染
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}

1.2结果

 

二、使用索引缓冲对象绘制橘色矩形

2.1代码

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

const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow* vWindow,int vWidth,int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow* vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,0.5f,0.2f,1.0f);\n"
"}\n\0";

//使用索引缓冲对象绘制一个橘色的矩形
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexShaderSource, NULL);
	glCompileShader(VertexShader);
	int Success;
	char InfoLog[512];
	glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(VertexShader, 512, NULL, InfoLog);
		std::cout << "error::shader::vertex::compilation failed\n" << InfoLog << std::endl;
	}
	int FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader, 1, &FragmentShaderSource, NULL);
	glCompileShader(FragmentShader);
	glGetShaderiv(FragmentShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(FragmentShader, 512, NULL, InfoLog);
		std::cout << "error::shader::fragment::compilation failed \n" << InfoLog << std::endl;
	}
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
	if (!Success)
	{
		glGetProgramInfoLog(ShaderProgram, 512, NULL, InfoLog);
		std::cout << "error::shader::Program::linking failed\n" << InfoLog << std::endl;
	}
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	float Vertices[] =
	{
		0.5f,0.5f,0.0f,
		0.5f,-0.5f,0.0f,
		-0.5f,-0.5f,0.0f,
		-0.5f,0.5f,0.0f
	};
	unsigned int Indices[] =
	{
		0,1,3,
		1,2,3
	};
	//新建顶点顶点数组对象、顶点缓冲对象、索引缓冲对象
	unsigned int VAO, VBO, EBO;
	glGenVertexArrays(1,&VAO);
	glGenBuffers(1, &VBO);
	glGenBuffers(1, &EBO);
	//先绑定顶点数组对象，然后绑定和设置顶点缓冲区，最后配置顶点属性
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER,0);
	glBindVertexArray(0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO);
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);
	glfwTerminate();
	return 0;
}

2.2结果

 

三、绘制两个彼此相连的橘色三角形

3.1代码

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

const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow* vWindow,int vWidth,int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow* vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,0.5f,0.2f,1.0f);\n"
"}\n\0";

int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	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);
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	float Vertice[] = 
	{
		0.0f,0.8f,0.0f,
		0.0f,0.0f,0.0f,
		-0.8f,0.0f,0.0f,
		0.0f,0.4f,0.0f,
		0.0f,0.0f,0.0f,
		0.8f,0.0f,0.0f
	};
	unsigned int VAO, VBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertice), Vertice, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 6);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;

}

3.2 结果

四、创建两个相同的三角形，使用不同的VAO和VBO

4.1代码

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

const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow* vWindow,int vWidth,int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow* vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,0.5f,0.2f,1.0f);\n"
"}\n\0";

//创建相同的两个三角形，但对它们的数据使用不同的VAO和VBO
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	float Vertices1[] =
	{
		0.0f,0.5f,0.0f,
		0.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f
	};
	float Vertices2[]=
	{
		0.0f,0.5f,0.0f,
		0.0f,0.0f,0.0f,
		0.5f,0.0f,0.0f
	};
	unsigned int VAO[2], VBO[2];
	glGenVertexArrays(2, VAO);
	glGenBuffers(2, VBO);
	glBindVertexArray(VAO[0]);
	glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices1), Vertices1, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(VAO[1]);
	glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices2), Vertices2, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(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);
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO[0]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glBindVertexArray(VAO[1]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();

	}
	glDeleteVertexArrays(2, VAO);
	glDeleteBuffers(2, VBO);
	glfwTerminate();
	return 0;
}

4.2结果

 

五、创建两个着色器程序，第二个程序使用一个不同的片段着色器，输出黄色；再次绘制这两个三角形，让其中一个输出为黄色

5.1代码

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

const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow* vWindow,int vWidth,int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow* vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,0.5f,0.2f,1.0f);\n"
"}\n\0";
const char *FragmentShaderSourceYe =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"	FragColor=vec4(1.0f,1.0f,0.0f,1.0f);\n"
"}\n\0";

//创建两个着色器程序，第二个程序使用一个不同的片段着色器，输出黄色；
//再次绘制这两个三角形，让其中一个输出为黄色
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexShaderSource, NULL);
	glCompileShader(VertexShader);
	int FragmentShader1 = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader1, 1, &FragmentShaderSource, NULL);
	glCompileShader(FragmentShader1);
	int FragmentShader2 = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader2, 1, &FragmentShaderSourceYe, NULL);
	glCompileShader(FragmentShader2);
	int ShaderProgram1 = glCreateProgram();
	glAttachShader(ShaderProgram1, VertexShader);
	glAttachShader(ShaderProgram1, FragmentShader1);
	glLinkProgram(ShaderProgram1);
	int ShaderProgram2 = glCreateProgram();
	glAttachShader(ShaderProgram2, VertexShader);
	glAttachShader(ShaderProgram2, FragmentShader2);
	glLinkProgram(ShaderProgram2);
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader1);
	glDeleteShader(FragmentShader2);
	float Vertices1 []=
	{
		0.0f,0.5f,0.0f,
		0.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f
	};
	float Vertices2[] =
	{
		0.0f,0.5f,0.0f,
		0.0f,0.0f,0.0f,
		0.5f,0.0f,0.0f
	};
	unsigned int VAO[2], VBO[2];
	glGenVertexArrays(2, VAO);
	glGenBuffers(2, VBO);
	glBindVertexArray(VAO[0]);
	glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices1), Vertices1, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(VAO[1]);
	glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices2), Vertices2, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram1);
		glBindVertexArray(VAO[0]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glUseProgram(ShaderProgram2);
		glBindVertexArray(VAO[1]);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(2, VAO);
	glDeleteBuffers(2, VBO);
	glfwTerminate();
	return 0;
}

5.2 结果

 

六、结语

第一课花费了好几天的学习，以后尽量做到一天学习一课。

 

煮雪品茶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL 绘制三角形
文耀的博客
10-25 261
#include <glad/glad.h> #include <GLFW/glfw3.h> #include <iostream> using namespace std; float color1=0.0, color2 = 0.0, color3 = 0.0, color4 = 0.0; float vertices[] = { -0.9,0,0, -0.45,0.45,0, 0,0,0, }; float vertices2[] = { 0,0,0,
【OpenGL 学习笔记】第 4 篇：绘制四边形
有朋自远方来，不亦乐乎。
06-25 1483
（0）选择x64平台 （1）添加链接打开项目属性打开项目目录添加文件路径：包含目录添加：D:\OpenGL_Link\Includes;库目录添加：D:\OpenGL_Link\Libs; 打开链接器/输入添加： 在项目源文件夹下添加glad.c文件 新建main.cpp文件，测试代码，没问题即可。 输出结果 包括：初始化GLFW、创建窗口、初始化GLAD、创建视口 2、顶点输入 3、数据处理 （1）VBO 我们有了顶点数据，接下来就是将这些顶点数据发送到GPU中去处理，这里我们
《Qt-OpenGL系列编程》课程学习记录（4）：OpenGL着色器语言（GLSL）
友善啊，朋友的博客
05-21 814
in 关键字定义的变量 in type in_variable_name; 表明此变量来自OpenGL管线。当前要定义一个变量保存它的值。 out 关键字定义的变量 out type out_variable_name; 表明此变量是要传到别的着色器的变量。 uniform 关键字定义的变量 uniform type uniform_name; 表明是可以由CPU和GPU都可以访问的变量。 顶点属性数量限制 OpenGL确保至少有16个包含4分量的顶点属性可用，
OpenGL绘制方式详解
先锋小牛
12-29 5281
简述 OpenGL绘制方式 OpenGL可以支持很多不同的图元类型，最基础的为点，线，或三角形。线和三角形可以组合成条带，循环体或者扇面三角形。点，线，或三角形也是大部分图象硬件设备支持的基础图元类型。   点 点可以通过单一的顶点来表示，点实际上不存在面积，在OpenGL中它通过屏幕上的一个矩形区域来模拟，在渲染点源的时候，OpenGL会通过光栅化规则类判断点的位置。以点位中心绘制一个
Python之OpenGL笔记(4)：使用不同的VAO、VBO和着色器画两个三角形
dalong10的专栏
04-22 1600
目的 1、创建相同的两个三角形，但对它们的数据使用不同的VAO和VBO： （类初始化实例时，初始数据生成不同的VAO） 2、创建两个着色器程序，第二个程序使用与第一个不同的片段着色器； 绘制这两个三角形，其中一个输出为绿色，一个输出为黄色： （类初始化实例时，根据side3的正负值，调用不同的片段着色器） 程序运行结果 顶点着色器 顶点着色器(Vertex Shad...
opengl画三角形
12-22
用opengl画一个简单的三角形，代码已经测试可用，可直接运行，供初学者学习使用。
OpenGL学习资料文档.rar
06-17
"与一个画三角形的示例小程序"是所有OpenGL学习者的起点。在计算机图形学中，三角形是最基本的形状，所有的复杂3D模型都可以分解为多个三角面片。这个示例程序将演示如何设置OpenGL环境，定义顶点，以及使用基本的...
OpenGL:学习现代3D图形编程之一，画一个三角形
03-24
画一个白色的三角形，详见我的博客
VSOpengl使用默认着色器画三角形
最新发布
12-19
总结起来，"VSOpengl使用默认着色器画三角形"这个项目是一个基础的OpenGL教程，涵盖了创建VS2019项目、配置OpenGL环境、编写和使用GLSL着色器、设置渲染管线、绘制三角形及管理OpenGL上下文等关键概念。通过这个项目...
Opengl画三角形
12-15
在这个“OpenGL画三角形”的项目中，我们将学习如何使用OpenGL来创建一个基本的三角形，并且通过键盘输入来改变其边的颜色。 首先，要实现OpenGL的基本功能，我们需要包含必要的头文件，如`GL/glut.h`或`GLFW/glfw3...
openGL之API学习（四十八）glDrawArrays
hankern的专栏
04-18 1739
从当前绑定的缓冲区中读取数据按照基本图元的形式绘制几何图形。 void glDrawArrays( GLenum mode, GLint first, GLsizei count); mode Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LI...
glDrawArrays与glDrawElements
kuovane的专栏
04-27 2864
glDrawArrays与glDrawElements 为了更直观的理解这两个方法的不同用处，下面举一个简单的代码例子： void onDraw() { ccGLBindTexture2D(_pSprite->getTexture()->getName()); ccGLBlendFunc(BlendFunc::ALPHA_NON_PREMULTIPLIED.src
OpenGL学习（二）绘制一个三角形
xhh22900的博客
05-27 429
参考官方文档：https://learnopengl-cn.github.io/ 首先，这个过程相当繁琐，需要做好思想准备。 首先先看源代码： #include<iostream> #include<glad/glad.h> #include<GLFW/glfw3.h> void processInput(GLFWwindow* window) { if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) glf
OpenGl学习笔记二：创建自己的着色器
Duoteng Xu
09-02 1622
每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。所以，如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。着色器是使用一种叫GLSL的类C语言写成的。GLSL中的向量是一个可以包含有2、3或者4个分量的容器，分量的类型可以是前面默认基础类型的任意一个。它们可以是下面的形式（Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。
opengl从画三角形到画一个立方体（一）
热门推荐
小孔明的专栏
09-30 2万+
主要内容： 画一个立方体，然后设计一个camera类。本文涉及的内容有点多，请读者耐心的看下去，这里不仅有软件的配置，还有shader的应用，以及摄像机类的编写，还包括一些矩阵变换之类的，闲话少说，具体内容一步一步展开。按照我们的思路，首先需要的是数据，顶点的数据，画一个立方体，需要八个顶点的数据。一个正方体如何画出来，需要一个面一个面的哈，那么正方体有6个面，而每个面呢？是一个正方形，我们把正方
几张图看明白VAO、VBO、EBO的关系和代码顺序
weixin_30389003的博客
10-18 546
0.详细教程可看https://learnopengl-cn.github.io/01%20Getting%20started/04%20Hello%20Triangle/ 1.可以简单地认为VAO的作用是这样的： 由于每渲染一次物体就要用一个VBO，而每次绑定一次VBO就要设置各个的顶点的属性，启动各个属性，代码十分复杂，复用性很差，因为每个物体的属性个数什么的都不一样（也就是说不是同构的）...
[learnOpenGL学习笔记_4] 你好，三角形 2
同学小张的博客
01-29 202
你好，三角形 2 文章目录你好，三角形 21. 索引缓冲对象（EBO/IBO）1.1 概念1.2 定义顶点和索引1.3 创建及配置1.4 绘制2. 全部源码3. 练习3.1 创建相同的两个三角形，但对它们的数据使用不同的VAO和VBO3.2 创建两个着色器程序，第二个程序使用一个不同的片段着色器，输出黄色；再次绘制这两个三角形，让其中一个输出为黄色 learnOpenGL网站是学习openGL非...
【GLFW 代码记录】入门使用
pzy的专栏
11-17 622
#include <iostream> #include <string> #include <fstream> #include <sstream> #include <glad/glad.h> #include <glfw3.h> //使用VAO #define USE_VAO 1 /* 三角形绘制基础代码 顶点数组对象：Vertex Array Object，VAO 顶点缓冲对象：Vertex .
OPENGL ES常用函数功能总结
huazi5dgan的专栏
07-06 1218
OPENGL ES常用函数功能总结1.创建缓冲区对象void glGenBuffers(GLsizei n, GLuint *buffers); //在buffers数组中返回当前n个未使用的名称，表示缓冲区对象 GLboolean glIsBuffer(GLuint buffer); //判断是否是缓冲区对象2.激活缓冲区对象void glBindBuffer(GLenum target, GLu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值