OpenGL 加载模型

最新推荐文章于 2023-06-17 12:18:32 发布
最新推荐文章于 2023-06-17 12:18:32 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skillart/article/details/97682198
版权

使用assimp加载，

引用动态链接库dll主要有两种方法：
法1：配置属性->调试->环境：输入path=包含dll文件的文件夹路径，

【注意】path(空格)=路径、path=(空格)路径、path(空格)=(空格)路径等写法都会导致dll引用失败。

法2：将dll文件拷贝到生成的.exe所在的文件夹中

代码:

// Std. Includes
#include <string>

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

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

// GL includes
#include "../../../common/Shader.h"
#include "../../../common/Camera.h"
#include "../../../common/Model.h"

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

// Other Libs
#include <SOIL.h>
using namespace myshader;
using namespace mycamera;


//去掉控制台
#pragma comment(linker,"/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
// Properties
GLuint screenWidth = 800, screenHeight = 600;

//按键回调函数
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
//鼠标回调函数
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
//滚轮回调函数
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
//处理按键
void do_movement();

// Camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
//记录按键信息
bool keys[1024];
GLfloat lastX = 400, lastY = 300;
bool firstMouse = true;

GLfloat deltaTime = 0.0f;
GLfloat lastFrame = 0.0f;

int main()
{
	// Init GLFW
	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* window = glfwCreateWindow(screenWidth, screenHeight, "Load Model", nullptr, nullptr); // Windowed
	glfwMakeContextCurrent(window);

	//窗口回调函数
	glfwSetKeyCallback(window, key_callback);
	glfwSetCursorPosCallback(window, mouse_callback);
	glfwSetScrollCallback(window, scroll_callback);

	// 隐藏鼠标
	//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

	// 将其设置为true，以便GLEW知道使用现代方法来检索函数指针和扩展
	glewExperimental = GL_TRUE;
	glewInit();

	// Define the viewport dimensions
	glViewport(0, 0, screenWidth, screenHeight);

	// 开启深度缓冲
	glEnable(GL_DEPTH_TEST);


	//定义顶点数组
	GLfloat vertices[] = {
			-0.5f, -0.5f, -0.5f,
			 0.5f, -0.5f, -0.5f,
			 0.5f,  0.5f, -0.5f,
			 0.5f,  0.5f, -0.5f,
			-0.5f,  0.5f, -0.5f,
			-0.5f, -0.5f, -0.5f,

			-0.5f, -0.5f,  0.5f,
			 0.5f, -0.5f,  0.5f,
			 0.5f,  0.5f,  0.5f,
			 0.5f,  0.5f,  0.5f,
			-0.5f,  0.5f,  0.5f,
			-0.5f, -0.5f,  0.5f,

			-0.5f,  0.5f,  0.5f,
			-0.5f,  0.5f, -0.5f,
			-0.5f, -0.5f, -0.5f,
			-0.5f, -0.5f, -0.5f,
			-0.5f, -0.5f,  0.5f,
			-0.5f,  0.5f,  0.5f,

			 0.5f,  0.5f,  0.5f,
			 0.5f,  0.5f, -0.5f,
			 0.5f, -0.5f, -0.5f,
			 0.5f, -0.5f, -0.5f,
			 0.5f, -0.5f,  0.5f,
			 0.5f,  0.5f,  0.5f,

			-0.5f, -0.5f, -0.5f,
			 0.5f, -0.5f, -0.5f,
			 0.5f, -0.5f,  0.5f,
			 0.5f, -0.5f,  0.5f,
			-0.5f, -0.5f,  0.5f,
			-0.5f, -0.5f, -0.5f,

			-0.5f,  0.5f, -0.5f,
			 0.5f,  0.5f, -0.5f,
			 0.5f,  0.5f,  0.5f,
			 0.5f,  0.5f,  0.5f,
			-0.5f,  0.5f,  0.5f,
			-0.5f,  0.5f, -0.5f
	};
	//光照相关
	GLuint lightVAO , VBO;
	glGenVertexArrays(1, &lightVAO);
	glGenBuffers(1, &VBO);
	glBindVertexArray(lightVAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	// 设置灯立方体的顶点属性指针(仅设置灯的顶点数据)
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);


	// 编译模型和光照着色器
	Shader shader("shaders/3.0/model_loading.vs", "shaders/3.0/model_loading.fs");
	Shader lightShader("shaders/2.2/light.vs", "shaders/2.2/light.fs");

	// 加载模型
	Model ourModel("models/Nanosuit/nanosuit.obj");

	// 线框模式
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	// 游戏循环
	while (!glfwWindowShouldClose(window))
	{
		// Set frame time
		GLfloat currentFrame = glfwGetTime();
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;

		//检测键盘 鼠标事件
		glfwPollEvents();
		do_movement();

		//清空颜色和深度缓冲
		glClearColor(0.05f, 0.05f, 0.05f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		shader.Use();  

		//点光源位置
		glm::vec3 lightPos[2];
		lightPos[0] = glm::vec3(1.0f + sin(glfwGetTime()) * 2.0f, sin(glfwGetTime() / 2.0f) * 1.0f, 1.9f);
		lightPos[1] = glm::vec3(1.0f - sin(glfwGetTime()) * 2.0f, -sin(glfwGetTime() / 2.0f) * 1.0f, -1.9f);

		//点光源颜色
		glm::vec3 lightColor[2];
		lightColor[0] = glm::vec3(sin(glfwGetTime()), cos(glfwGetTime()), 1 - (sin(glfwGetTime()) + cos(glfwGetTime())));
		lightColor[1] = glm::vec3(cos(glfwGetTime()), sin(glfwGetTime()), (sin(glfwGetTime()) + cos(glfwGetTime())));

		// 点光源1
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[0].position"), lightPos[0].x, lightPos[0].y, lightPos[0].z);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[0].diffuse"), 0.8f, 0.8f, 0.8f);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[0].specular"), lightColor[0].r, lightColor[0].g, lightColor[0].b);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[0].constant"), 1.0f);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[0].linear"), 0.09);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[0].quadratic"), 0.032);
		// 点光源2
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[1].position"), lightPos[1].x, lightPos[1].y, lightPos[1].z);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[1].diffuse"), 0.8f, 0.8f, 0.8f);
		glUniform3f(glGetUniformLocation(shader.Program, "pointLights[1].specular"), lightColor[0].r, lightColor[0].g, lightColor[0].b);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[1].constant"), 1.0f);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[1].linear"), 0.09);
		glUniform1f(glGetUniformLocation(shader.Program, "pointLights[1].quadratic"), 0.032);

		//获取在shader里的位置
		GLint viewPosLoc = glGetUniformLocation(shader.Program, "viewPos");
		glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);

		// MVP
		glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth / (float)screenHeight, 0.1f, 100.0f);
		glm::mat4 view = camera.GetViewMatrix();
		glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
		glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));

		// 渲染模型
		glm::mat4 model;
		model = glm::translate(model, glm::vec3(0.0f, -1.75f, 0.0f)); // Translate it down a bit so it's at the center of the scene
		model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f));	// It's a bit too big for our scene, so scale it down
		glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
		ourModel.Draw(shader);

		//渲染光源
		lightShader.Use();
		for (int i = 0; i < 2; i++)
		{
			model = glm::mat4();
			model = glm::translate(model, lightPos[i]);
			model = glm::scale(model, glm::vec3(0.2f));
			GLint modeLoc = glGetUniformLocation(lightShader.Program, "model");
			GLint viewLoc = glGetUniformLocation(lightShader.Program, "view");
			GLint projectionLoc = glGetUniformLocation(lightShader.Program, "projection");
			GLuint lightColorLoc = glGetUniformLocation(lightShader.Program, "lightColor");
			glUniform3f(lightColorLoc, lightColor[i].x, lightColor[i].y, lightColor[i].z);
			glUniformMatrix4fv(modeLoc, 1, GL_FALSE, glm::value_ptr(model));
			glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
			glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
			glBindVertexArray(lightVAO);
			glDrawArrays(GL_TRIANGLES, 0, 36);
			glBindVertexArray(0);
		}
		

		// 双缓冲
		glfwSwapBuffers(window);
	}

	glfwTerminate();
	return 0;
}

#pragma region "User input"

// Moves/alters the camera positions based on user input
void do_movement()
{
	// Camera controls
	if (keys[GLFW_KEY_W])
		camera.ProcessKeyboard(FORWARD, deltaTime);
	if (keys[GLFW_KEY_S])
		camera.ProcessKeyboard(BACKWARD, deltaTime);
	if (keys[GLFW_KEY_A])
		camera.ProcessKeyboard(LEFT, deltaTime);
	if (keys[GLFW_KEY_D])
		camera.ProcessKeyboard(RIGHT, deltaTime);
}

// Is called whenever a key is pressed/released via GLFW
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, GL_TRUE);

	if (action == GLFW_PRESS)
		keys[key] = true;
	else if (action == GLFW_RELEASE)
		keys[key] = false;
}

void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	if (firstMouse)
	{
		lastX = xpos;
		lastY = ypos;
		firstMouse = false;
	}

	GLfloat xoffset = xpos - lastX;
	GLfloat yoffset = lastY - ypos;

	lastX = xpos;
	lastY = ypos;

	camera.ProcessMouseMovement(xoffset, yoffset);
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
	camera.ProcessMouseScroll(yoffset);
}

#pragma endregion

模型顶点Shader:

#version 330 core
layout (location = 0) in vec3 position;
layout (location = 1) in vec3 normal;
layout (location = 2) in vec2 texCoords;

out vec2 TexCoords;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
out vec3 Normal;
out vec3 FragPos;

void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0f);
    TexCoords = texCoords;
    FragPos = vec3(model * vec4(position, 1.0f));
    Normal = mat3(transpose(inverse(model))) * normal;  
}

模型片段Shader:

#version 330 core

struct PointLight {
    vec3 position;
    
    float constant;
    float linear;
    float quadratic;
    
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

struct Material {
    sampler2D diffuse;
    sampler2D specular;
    float shininess;
}; 

in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;
uniform vec3 viewPos;

out vec4 color;

uniform sampler2D texture_diffuse1;
#define NR_POINT_LIGHTS 2
uniform PointLight pointLights[NR_POINT_LIGHTS];
uniform Material material;

vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir);

void main()
{    
    color = vec4(texture(texture_diffuse1, TexCoords));

    vec3 norm = normalize(Normal);
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 lightColor = vec3(0,0,0);
    for(int i = 0; i < NR_POINT_LIGHTS; i++)
        lightColor += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
    color = vec4(lightColor ,1.0);
}



vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    vec3 lightDir = normalize(light.position - fragPos);
    // Diffuse shading
    float diff = max(dot(normal, lightDir), 0.0);
    // Specular shading
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    // Attenuation
    float distance = length(light.position - fragPos);
    float attenuation = 1.0f / (light.constant + light.linear * distance + light.quadratic * (distance * distance));    
    // Combine results
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
    ambient *= attenuation;
    diffuse *= attenuation;
    specular *= attenuation;
    return (ambient + diffuse + specular);
}

光源顶点Shader：

#version 330 core
uniform vec3 lightColor;
out vec4 color;

void main()
{
    color = vec4(lightColor,1.0);
}

光源片段Shader:

#version 330 core
layout (location = 0) in vec3 position;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0f);
}

效果:

参考文章:https://learnopengl-cn.readthedocs.io/zh/latest/03%20Model%20Loading/03%20Model/

skillart
关注
专栏目录
【LearnOpenGL学习笔记】——13.模型加载
qq_45974407的博客
04-26 562
文章目录 1.数据格式 3D建模工具生成的数据文件格式.obj或COLLADA格式，通过模型导入库Assimp能在OpenGL中使用模型数据——了解.obj格式数据格式 2.Assimp库导入方法 （1）到GitHub下载Assimp （2）通过CMake ...
openGL加载3D模型
05-15
openGL加载3D模型，非常实用，对于学习openGL的初学者很有用处
OpenGL基础图形编程 - OpenGL建模
popkiler的专栏
08-22 1696
OpenGL基本库提供了大量绘制各种类型图元的方法，辅助库也提供了不少描述复杂三维图形的函数。这一章主要介绍基本图元，如点、线、多边形，有了这些图元，就可以建立比较复杂的模型了。7.1、描述图元　　OpenGL是三维图形的函数库，它所定义的点、线、多边形等图元与一般的定义不太一样，存在一定的差别。对编程者来说，能否理解二者之间的差别十分重要。一种差别源于基于计算机计算的限制。OpenGL中所有浮点
opengl-模型加载
笃笃前行的专栏
12-24 682
opengl-模型加载模型加载库网格初始化渲染模型导入3D模型到OpenGL从Assimp到网格索引材质重大优化 模型加载库 一个非常流行的模型导入库是 Assimp，它是 Open Asset Import Library（开放的资产导入库）的缩写 ** Assimp数据结构的（简化）模型如下 ** 网格 OpenGL中定义一个顶点, 每个顶点包含一个位置向量、一个法向量和一个纹理坐标向量 s...
从0开始的OpenGL学习（十七）-加载模型
翻肚鱼儿的博客
07-21 1187
阅读 7,352 本文主要解决一个问题： 如何在OpenGL中加载模型？ 引言 学到现在，我们把盒子兄弟折磨得死去活来，虽说弄出了一些效果，但也总是感觉有点不给力，换个时髦的说法就是：用户体验不好。在实际的图形应用中，会有很多复杂并且有趣的模型，比我们的盒子强太多。但是，由于太复杂，我们不可能手动定义模型的顶点坐标、法线和纹理坐标等值。我们希望的是，直接把模型导入到应用中使用，把创建模型的工作交给专业的建模师去做。他们有很高端的工具，例如3DS Max、Maya等等。 这些3D建模工具十分强大
opengl模型加载
缥缈的云 专栏
09-02 4002
opengl模型加载
QT + OpenGL加载模型展示
10-10
QT + OpenGL加载模型展示
Qt+opengl加载各种类型的3D模型，.glb .obj 等；Qt+opengl加载各种类型的3D模型，.glb .obj
最新发布
01-15
Qt+opengl加载各种类型的3D模型，.glb .obj 等；Qt+opengl加载各种类型的3D模型，.glb .obj 等；Qt+opengl加载各种类型的3D模型，.glb .obj 等；Qt+opengl加载各种类型的3D模型，.glb .obj 等；Qt+opengl加载各种...
OpenGl加载三维模型源代码
03-26
Opengl 三维模型 源代码 三维素材，Mesh的概念，Obj模型数据格式，Obj模型简单，的加载类和加载实验。 前面介绍了光照基础内容，以及材质和lighting maps，和光源类型，我们对使用光照增强场景真实感有了一定了解。但是到目前为止，我们通过在程序中指定的立方体数据，绘制立方体，看起来还是很乏味。本节开始介绍模型加载，通过加载丰富的模型，能够丰富我们的场景，变得好玩。
Opengl如何从一个文件中加载3D模型
08-19
如何从一个文件中读取模型数据。通过该例子，你将学会如何从文件加载3D模型，并且平滑的从一个模型变换为另一个模型。
opengl 开发模型
10-13
VS2013下建立的Opengl模型，#include <GL/glut.h> static const float vertex_list[][3] = { -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, }; // 将要使用的顶点的序号保存到一个数组里面 static const GLint index_list[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 }, { 6, 7 }, { 0, 2 }, { 1, 3 }, { 4, 6 }, { 5, 7 }, { 0, 4 }, { 1, 5 }, { 7, 3 }, { 2, 6 } }; // 绘制立方体
OpenGL使用Assimp库加载3d模型
04-23
现代OpenGL，利用Assimp进行3d模型加载的一个Demo，提供了两个3d模型，能很好的加载含纹理的.obj格式的3d模型。博客地址：https://blog.csdn.net/lady_killer9/article/details/89458246
openGL3D模型贴图
06-14
使用opengl对3d模型进行贴图贴纹理，使用vs2017直接打开运行即可
opengl加载模型
06-17
基于opengl的win32中，导入一个房子模型，并有简单的旋转！
openGL加载obj三维模型，并且在模型上添加光照
02-22
1.openGL加载obj三维模型， 2.并且在模型上添加光照 3.Blinn-Phong 着色
OpenGL模型加载
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
06-17 819
网格(Mesh)代表的是单个的可绘制实体。一个网格应该至少需要一系列的顶点，每个顶点包含一个位置向量、一个法向量和一个纹理坐标向量。一个网格还应该包含用于索引绘制的索引以及纹理形式的材质数据（漫反射/镜面光贴图）。//位置//法向量//纹理坐标//纹理ID//类型//路径public:private:private://创建VBO和VAO对象，并赋予ID//绑定VBO和VAO对象//为当前绑定到target的缓冲区对象创建一个新的数据存储。
OpenGL学习笔记（六）-模型加载
Catog的博客
04-15 812
参考网址：LearnOpenGL 中文版 哔哩哔哩教程 第三章 模型加载 3.1 Assimp 1、Assimp能够导入多种模型文件格式，将所有的模型数据加载至Assimp的通用数据结构中，我们就能够从Assimp的数据结构中提取我们所需的所有数据了。 2、Assimp会将整个模型加载进一个场景对象，场景对象中包含一系列的节点，每个节点包含了场景对象中所储存数据的索引，每个节点都可以有任意数量的子节点。（图中左半边） 场景的根节点含子节点，子节点中有一系列指向场景对象中mMeshes数组中储存的网格数据的
OpenGL加载与显示3DS模型详解
"这篇文档主要讨论了如何在OpenGL环境下读取和显示3DS文件，这是一种常用的三维模型格式。文中详细介绍了3DS文件的结构和块的组织方式，以及如何通过编程接口将3DS数据转化为OpenGL可渲染的模型。此外，还提到了文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值