技术教程 C++ OpenGL实现旋转立方体的绘制 正文

C++ OpenGL实现旋转立方体的绘制

2022-07-29,,,

1、z-缓冲

//开启深度测试
glenable(gl_depth_test);

2、glm库函数

3、pvm矩阵

4、pvm矩阵的使用

我们需要引入glm函数库的头文件：

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

设置vew矩阵的相关参数：

//相机参数
glm::vec3 camera_position = glm::vec3(0.0f, 0.0f, 3.0f);     //摄像机位置
glm::vec3 camera_front = glm::vec3(0.0f, 0.0f, -1.0f);       //摄像机方向
glm::vec3 camera_up = glm::vec3(0.0f, 1.0f, 0.0f);           //摄像机上向量

设置project矩阵视野fov：

float fov = 45.0f;

// transform坐标变换矩阵
		glm::mat4 model(1);//model矩阵，局部坐标变换至世界坐标
		model = glm::translate(model, glm::vec3(0.0,0.0,0.0));
		model = glm::rotate(model, (float)glfwgettime(), glm::vec3(0.5f, 1.0f, 0.0f));
		model = glm::scale(model, glm::vec3(1.0f,1.0f,1.0f));

glm::mat4 view(1);//view矩阵，世界坐标变换至观察坐标系
		view = glm::lookat(camera_position, camera_position + camera_front, camera_up);

glm::mat4 projection(1);//projection矩阵，投影矩阵
		projection = glm::perspective(glm::radians(fov), (float)screen_width / screen_height, 0.1f, 100.0f);

int model_location = glgetuniformlocation(shader.id, "model"); //获取着色器内某个参数的位置
		

gluniformmatrix4fv(model_location, 1, gl_false, glm::value_ptr(model));//写入参数值

gl_position=projection*view*model*vec4(apos,1.0);

5、工程文件结构

shader.h

#ifndef __shader_h__
#define __shader_h__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class shader
{
public:
	unsigned int id;
 
	shader(const glchar* vertex_shader_path, const glchar* fragment_shader_path);
	~shader();
 
	void use();
	void setbool(const std::string &name, bool value) const;
	void setint(const std::string &name, int value) const;
	void setfloat(const std::string &name, float value) const;
	void setvec2(const std::string &name, const glm::vec2 &value) const;
	void setvec2(const std::string &name, float x, float y) const;
	void setvec3(const std::string &name, const glm::vec3 &value) const;
	void setvec3(const std::string &name, float x, float y, float z) const;
	void setvec4(const std::string &name, const glm::vec4 &value) const;
	void setvec4(const std::string &name, float x, float y, float z, float w) const;
	void setmat2(const std::string &name, const glm::mat2 &value) const;
	void setmat3(const std::string &name, const glm::mat3 &value) const;
	void setmat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int getshaderfromfile(const glchar* vertex_shader_path, const glchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int linkshader(const char* vertex_shader_code, const char* fragment_shader_code);
	int getuniform(const std::string &name) const;
	void checkcompileerrors(gluint shader, std::string type);
};
 
#endif // !__shader_h__
#ifndef __shader_h__
#define __shader_h__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class shader
{
public:
	unsigned int id;
 
	shader(const glchar* vertex_shader_path, const glchar* fragment_shader_path);
	~shader();
 
	void use();
	void setbool(const std::string &name, bool value) const;
	void setint(const std::string &name, int value) const;
	void setfloat(const std::string &name, float value) const;
	void setvec2(const std::string &name, const glm::vec2 &value) const;
	void setvec2(const std::string &name, float x, float y) const;
	void setvec3(const std::string &name, const glm::vec3 &value) const;
	void setvec3(const std::string &name, float x, float y, float z) const;
	void setvec4(const std::string &name, const glm::vec4 &value) const;
	void setvec4(const std::string &name, float x, float y, float z, float w) const;
	void setmat2(const std::string &name, const glm::mat2 &value) const;
	void setmat3(const std::string &name, const glm::mat3 &value) const;
	void setmat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int getshaderfromfile(const glchar* vertex_shader_path, const glchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int linkshader(const char* vertex_shader_code, const char* fragment_shader_code);
	int getuniform(const std::string &name) const;
	void checkcompileerrors(gluint shader, std::string type);
};
 
#endif // !__shader_h__
#ifndef __shader_h__
#define __shader_h__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class shader
{
public:
	unsigned int id;
 
	shader(const glchar* vertex_shader_path, const glchar* fragment_shader_path);
	~shader();
 
	void use();
	void setbool(const std::string &name, bool value) const;
	void setint(const std::string &name, int value) const;
	void setfloat(const std::string &name, float value) const;
	void setvec2(const std::string &name, const glm::vec2 &value) const;
	void setvec2(const std::string &name, float x, float y) const;
	void setvec3(const std::string &name, const glm::vec3 &value) const;
	void setvec3(const std::string &name, float x, float y, float z) const;
	void setvec4(const std::string &name, const glm::vec4 &value) const;
	void setvec4(const std::string &name, float x, float y, float z, float w) const;
	void setmat2(const std::string &name, const glm::mat2 &value) const;
	void setmat3(const std::string &name, const glm::mat3 &value) const;
	void setmat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int getshaderfromfile(const glchar* vertex_shader_path, const glchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int linkshader(const char* vertex_shader_code, const char* fragment_shader_code);
	int getuniform(const std::string &name) const;
	void checkcompileerrors(gluint shader, std::string type);
};
 
#endif // !__shader_h__

shader.cpp

#include "shader.h"
#include "fstream"
#include "sstream"
#include "iostream"
 
shader::shader(const glchar* vertex_shader_path, const glchar* fragment_shader_path)
{
	std::string vertex_shader_code;
	std::string fragment_shader_code;
	if (getshaderfromfile(vertex_shader_path, fragment_shader_path, &vertex_shader_code, &fragment_shader_code))
	{
		return;
	}
	if (linkshader(vertex_shader_code.c_str(), fragment_shader_code.c_str()))
	{
		return;
	}
}
 
shader::~shader()
{
 
}
 
void shader::use()
{
	gluseprogram(id);
}
 
void shader::setbool(const std::string &name, bool value) const
{
	setint(name, (int)value);
}
 
void shader::setint(const std::string &name, int value) const
{
	gluniform1i(getuniform(name), value);
}
 
void shader::setfloat(const std::string &name, float value) const
{
	gluniform1f(getuniform(name), value);
}
 
void shader::setvec2(const std::string &name, float x, float y) const
{
	gluniform2f(getuniform(name), x, y);
}
 
void shader::setvec2(const std::string &name, const glm::vec2 &value) const
{
	setvec2(name, value.x, value.y);
}
 
void shader::setvec3(const std::string &name, float x, float y, float z) const
{
	gluniform3f(getuniform(name), x, y, z);
}
 
void shader::setvec3(const std::string &name, const glm::vec3 &value) const
{
	setvec3(name, value.x, value.y, value.z);
}
 
void shader::setvec4(const std::string &name, float x, float y, float z, float w) const
{
	gluniform4f(getuniform(name), x, y, z, w);
}
 
void shader::setvec4(const std::string &name, const glm::vec4 &value) const
{
	setvec4(name, value.x, value.y, value.z, value.w);
}
 
void shader::setmat2(const std::string &name, const glm::mat2 &value) const
{
	gluniformmatrix2fv(getuniform(name), 1, gl_false, &value[0][0]);
}
 
void shader::setmat3(const std::string &name, const glm::mat3 &value) const
{
	gluniformmatrix3fv(getuniform(name), 1, gl_false, &value[0][0]);
}
 
void shader::setmat4(const std::string &name, const glm::mat4 &value) const
{
	gluniformmatrix4fv(getuniform(name), 1, gl_false, &value[0][0]);
}
 
int shader::getshaderfromfile(const glchar* vertex_shader_path, const glchar* fragment_shader_path, std::string *vertex_shader_code, std::string *fragment_shader_code)
{
	std::ifstream vertex_shader_file;
	std::ifstream fragment_shader_file;
	vertex_shader_file.exceptions(std::ifstream::badbit | std::ifstream::failbit);
	fragment_shader_file.exceptions(std::ifstream::badbit | std::ifstream::failbit);
	try
	{
		vertex_shader_file.open(vertex_shader_path);
		fragment_shader_file.open(fragment_shader_path);
		std::stringstream vertex_shader_stream, fragment_shader_stream;
		vertex_shader_stream << vertex_shader_file.rdbuf();
		fragment_shader_stream << fragment_shader_file.rdbuf();
		vertex_shader_file.close();
		fragment_shader_file.close();
		*vertex_shader_code = vertex_shader_stream.str();
		*fragment_shader_code = fragment_shader_stream.str();
	}
	catch (std::ifstream::failure e)
	{
		std::cout << "load shader file error!" << std::endl;
		return -1;
	}
	return 0;
}
 
int shader::linkshader(const char* vertex_shader_code, const char* fragment_shader_code)
{
	int vertex_shader = glcreateshader(gl_vertex_shader);
	glshadersource(vertex_shader, 1, &vertex_shader_code, null);
	glcompileshader(vertex_shader);
	checkcompileerrors(vertex_shader, "vertex");
 
	int fragment_shader = glcreateshader(gl_fragment_shader);
	glshadersource(fragment_shader, 1, &fragment_shader_code, null);
	glcompileshader(fragment_shader);
	checkcompileerrors(fragment_shader, "fragment");
 
	this->id = glcreateprogram();
	glattachshader(id, vertex_shader);
	glattachshader(id, fragment_shader);
	gllinkprogram(id);
	checkcompileerrors(id, "program");
 
	gldeleteshader(vertex_shader);
	gldeleteshader(fragment_shader);
	return 0;
}
 
int shader::getuniform(const std::string &name) const
{
	int position = glgetuniformlocation(id, name.c_str());
	if (position == -1)
	{
		std::cout << "uniform " << name << " set failed!" << std::endl;
	}
	return position;
}
 
void shader::checkcompileerrors(gluint shader, std::string type)
{
	glint success;
	glchar infolog[512];
	if (type == "program")
	{
		glgetprogramiv(shader, gl_link_status, &success);
		if (!success)
		{
			glgetprograminfolog(shader, 512, null, infolog);
			std::cout << "error::program_linking_error!\n" << infolog << std::endl;
		}
	}
	else
	{
		glgetshaderiv(shader, gl_compile_status, &success);
		if (!success)
		{
			glgetshaderinfolog(shader, 512, null, infolog);
			std::cout << "error::shader::" << type << "::compilation_failed\n" << infolog << std::endl;
		}
	}
}

main.cpp 

//总体流程
//1. 初始化并创建窗口
//2. 加载立方体顶点vaovbo以及着色器并开启深度测试
//3. 进入主循环清除缓冲
//4. 使用立方体着色器，构造并传入pvm矩阵，绘制
//5. 循环结束，释放vaovbo
 
#include <iostream>
#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 "shader.h"
 
const float vertices[] = {                  //立方体数组
	-0.5f, -0.5f, -0.5f, 1.0f,0.0f,0.0f,
	0.5f, -0.5f, -0.5f,  1.0f,0.0f,0.0f,
	0.5f,  0.5f, -0.5f,  1.0f,0.0f,0.0f,
	0.5f,  0.5f, -0.5f,  1.0f,0.0f,0.0f,
	-0.5f,  0.5f, -0.5f,  1.0f,0.0f,0.0f,
	-0.5f, -0.5f, -0.5f,  1.0f,0.0f,0.0f,
 
	-0.5f, -0.5f,  0.5f,  0.0f,1.0f,0.0f,
	0.5f, -0.5f,  0.5f,  0.0f,1.0f,0.0f,
	0.5f,  0.5f,  0.5f,  0.0f,1.0f,0.0f,
	0.5f,  0.5f,  0.5f,  0.0f,1.0f,0.0f,
	-0.5f,  0.5f,  0.5f,  0.0f,1.0f,0.0f,
	-0.5f, -0.5f,  0.5f,  0.0f,1.0f,0.0f,
 
	-0.5f,  0.5f,  0.5f,  0.0f,0.0f,1.0f,
	-0.5f,  0.5f, -0.5f,  0.0f,0.0f,1.0f,
	-0.5f, -0.5f, -0.5f,  0.0f,0.0f,1.0f,
	-0.5f, -0.5f, -0.5f,  0.0f,0.0f,1.0f,
	-0.5f, -0.5f,  0.5f,  0.0f,0.0f,1.0f,
	-0.5f,  0.5f,  0.5f,  0.0f,0.0f,1.0f,
 
	0.5f,  0.5f,  0.5f,  0.5f,0.0f,0.0f,
	0.5f,  0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f,  0.5f,  0.5f,0.0f,0.0f,
	0.5f,  0.5f,  0.5f,  0.5f,0.0f,0.0f,
 
	-0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	-0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	-0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
 
	-0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	-0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	-0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f
};
 
float screen_width = 1280.0f;          //窗口宽度
float screen_height = 720.0f;          //窗口高度
//相机参数
glm::vec3 camera_position = glm::vec3(0.0f, 0.0f, 3.0f);     //摄像机位置
glm::vec3 camera_front = glm::vec3(0.0f, 0.0f, -1.0f);       //摄像机方向
glm::vec3 camera_up = glm::vec3(0.0f, 1.0f, 0.0f);           //摄像机上向量
//视野
float fov = 45.0f;
 
int main() {
	// 初始化glfw
	glfwinit();                                                     // 初始化glfw
	glfwwindowhint(glfw_context_version_major, 3);                  // opengl版本为3.3，主次版本号均设为3
	glfwwindowhint(glfw_context_version_minor, 3);
	glfwwindowhint(glfw_opengl_profile, glfw_opengl_core_profile);  // 使用核心模式(无需向后兼容性)
	glfwwindowhint(glfw_opengl_forward_compat, gl_true);            // 如果使用的是mac os x系统，需加上这行
	glfwwindowhint(glfw_resizable, false);						    // 不可改变窗口大小
 
																	// 创建窗口(宽、高、窗口名称)
	auto window = glfwcreatewindow(screen_width, screen_height, "cube", nullptr, nullptr);
	if (window == nullptr) {                                        // 如果窗口创建失败，输出failed to create opengl context
		std::cout << "failed to create opengl context" << std::endl;
		glfwterminate();
		return -1;
	}
	glfwmakecontextcurrent(window);                                 // 将窗口的上下文设置为当前线程的主上下文
 
																	// 初始化glad，加载opengl函数指针地址的函数
	if (!gladloadglloader((gladloadproc)glfwgetprocaddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
 
	// 指定当前视口尺寸(前两个参数为左下角位置，后两个参数是渲染窗口宽、高)
	glviewport(0, 0, screen_width, screen_height);
 
 
	shader shader("res/shader/task-cube.vs", "res/shader/task-cube.fs");//加载着色器
 
	// 生成并绑定vao和vbo
	gluint vertex_array_object; // == vao
	glgenvertexarrays(1, &vertex_array_object);
	glbindvertexarray(vertex_array_object);
 
	gluint vertex_buffer_object; // == vbo
	glgenbuffers(1, &vertex_buffer_object);
	glbindbuffer(gl_array_buffer, vertex_buffer_object);
	// 将顶点数据绑定至当前默认的缓冲中
	glbufferdata(gl_array_buffer, sizeof(vertices), vertices, gl_static_draw);
 
	// 设置顶点属性指针
	glvertexattribpointer(0, 3, gl_float, gl_false, 6 * sizeof(float), (void*)0);
	glenablevertexattribarray(0);
 
	glvertexattribpointer(1, 3, gl_float, gl_false, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glenablevertexattribarray(1);
 
 
	glenable(gl_depth_test);
	// render loop主循环
	while (!glfwwindowshouldclose(window)) {
		//进入主循环，清理颜色缓冲深度缓冲
		glclearcolor(0.0f, 0.34f, 0.57f, 1.0f);
		glclear(gl_color_buffer_bit | gl_depth_buffer_bit);//清理颜色缓冲和深度缓冲
 
		shader.use();
 
		// transform坐标变换矩阵
		glm::mat4 model(1);//model矩阵，局部坐标变换至世界坐标
		model = glm::translate(model, glm::vec3(0.0,0.0,0.0));
		model = glm::rotate(model, (float)glfwgettime(), glm::vec3(0.5f, 1.0f, 0.0f));
		model = glm::scale(model, glm::vec3(1.0f,1.0f,1.0f));
		glm::mat4 view(1);//view矩阵，世界坐标变换至观察坐标系
		view = glm::lookat(camera_position, camera_position + camera_front, camera_up);
		glm::mat4 projection(1);//projection矩阵，投影矩阵
		projection = glm::perspective(glm::radians(fov), (float)screen_width / screen_height, 0.1f, 100.0f);
 
		
		// 向着色器中传入参数
		int model_location = glgetuniformlocation(shader.id, "model"); //获取着色器内某个参数的位置
		gluniformmatrix4fv(model_location, 1, gl_false, glm::value_ptr(model));//写入参数值
		int view_location = glgetuniformlocation(shader.id, "view");
		gluniformmatrix4fv(view_location, 1, gl_false, glm::value_ptr(view));
		int projection_location = glgetuniformlocation(shader.id, "projection");
		gluniformmatrix4fv(projection_location, 1, gl_false, glm::value_ptr(projection));
		//绘制
		glbindvertexarray(vertex_array_object);
		gldrawarrays(gl_triangles, 0, 36);
		glbindvertexarray(0);
		
		
		glfwswapbuffers(window);
		glfwpollevents();
	}
	//释放vaovbo
	gldeletevertexarrays(1, &vertex_array_object);
	gldeletebuffers(1, &vertex_buffer_object);
 
	// 清理所有的资源并正确退出程序
	glfwterminate();
	return 0;
}

输出结果：

到此这篇关于c++ opengl实现旋转立方体的绘制的文章就介绍到这了,更多相关c++ opengl旋转立方体内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

《C++ OpenGL实现旋转立方体的绘制.doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!