OpenGL学习笔记（十三）模型的加载

最新推荐文章于 2023-03-09 15:38:40 发布
最新推荐文章于 2023-03-09 15:38:40 发布
阅读量611 收藏 1
点赞数 1
分类专栏： OpenGl 文章标签： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41487299/article/details/100169400
版权

关于openGl模型的加载需要使用到Assimp库，非常喜闻乐见的是如果你用的编译器是Vs的话，就能通过NuGet直接获取到这个库，装载即可。我这里就不演示了！直接去网上搜索一下就知道怎么安装包了。
在这里插入图片描述
根据上图，我们可以看到模型中有一个scene场景，然后左边的是则是各种节点，我们要的做就是遍历左边的接单获取到右边的数据。
我们可以看到我们目前还缺少一个网格类。
Mesh.h

#pragma once
#include<glm/glm.hpp>
#include<string>
#include<vector>
#include"Shader.h"
#include<Gl/glew.h>
#include <assimp/Importer.hpp>

struct Vertex//顶点结构体
{
	glm::vec3 Position;
	glm::vec3 Normal;
	glm::vec2 TexCoords;
};
struct Texture{//贴图结构体
	unsigned int id;
	std::string type;
	aiString path;
};
class Mesh
{
public :
	std::vector<Vertex> vertices;//顶点容器，似乎就是个动态列表
	std::vector<Texture> textures;//贴图容器
	std::vector<unsigned int> indices;//EBO绘制的索引，
	Mesh(float vertices[]);//给你测试网格类是否出错的，输入我们前面的那个组就能直接绘画出正方体
	Mesh(std::vector<Vertex> vertices,std::vector<Texture> textures,std::vector<unsigned int> indices);//这是带三个参数构造函数
	void Draw(Shader* shader);//绘制
private:
	unsigned int VAO, VBO, EBO;//这些相信你应该还有映像吧，就是我们将顶点的绘制封装成一个类
	void SteupMesh();//初始化网格类	
};

Mesh.cpp

#include "Mesh.h"
#include <string>
#include<iostream>
Mesh::Mesh(float vertices[])//测试用的
{
	this->vertices.resize(36);
	memcpy(&(this->vertices[0]),vertices,36*8*sizeof(float));
	SteupMesh();
}

Mesh::Mesh(std::vector<Vertex> vertices, std::vector<Texture> textures, std::vector<unsigned int> indices)//构造
{
	this->vertices = vertices;
	this->indices = indices;
	this->textures = textures;
	SteupMesh();
}
void Mesh::Draw(Shader* shader)//绘制网格
{
	for (GLuint i = 0; i < this->textures.size(); i++)//遍历贴图容器
	{
		std::string name = this->textures[i].type;
		if (name == "texture_diffuse")//如果类型为diffuse,就放到0号槽位
		{
			glActiveTexture(GL_TEXTURE0);
			glBindTexture(GL_TEXTURE_2D,this->textures[i].id);
			shader->SetUniform1i("material.diffuse",0);
		}
		else if(name =="texture_specular")//如果类型为specular,就放到1号槽位
		{ 
			glActiveTexture(GL_TEXTURE1);
			glBindTexture(GL_TEXTURE_2D, this->textures[i].id);
			shader->SetUniform1i("material.specular",1);
		}
	}	
	glBindVertexArray(this->VAO);
	//测试时绘制正方体时使用，
	//glDrawArrays(GL_TRIANGLES,0,36);
   //根据元素索引绘制，测试时需要注释掉
	glDrawElements(GL_TRIANGLES,indices.size(),GL_UNSIGNED_INT,0);
	glBindVertexArray(0);
	glBindTexture(GL_TEXTURE_2D,0);
}
//这个就不讲了，就是绘制网格的流水线配置
void Mesh::SteupMesh()
{
	glGenVertexArrays(1,&VAO);
	glBindVertexArray(VAO);
	glGenBuffers(1,&VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER,sizeof(Vertex)* vertices.size(),&vertices[0],GL_STATIC_DRAW);
//测试绘制的时候，需要注释掉下面三行，因为测试绘制没有索引属性。
	glGenBuffers(1,&EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(unsigned     int)*indices.size(),&indices[0],GL_STATIC_DRAW);
	
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glEnableVertexAttribArray(2);
	glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(Vertex),(GLvoid*)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(3*sizeof(GL_FLOAT)));
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(6 * sizeof(GL_FLOAT)));
	glBindVertexArray(0);
}

如要测试，只要在main.cpp中输入

Mesh mesh(vertices);
mesh.Draw(myShader);

就能得到一个正方体了，注意该注释的要注释掉。

接下来是
Model.h

#pragma once
#include<string>
#include<vector>
#include"Mesh.h"
#include"Shader.h"
#include<iostream>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

class Model
{
public :
	Model(std::string path);//构造
	void Draw(Shader* shader);
	
private:
	std::vector<Mesh> meshes;//网格容器
	std::vector<Texture> textures_loaded;//记录已经加载过的贴图
	std::string directory;//路径
	void loadModel(std::string path);//加载模型
	void processNode(aiNode* node, const aiScene *scene);//查找节点
	Mesh processMesh(aiMesh* mesh, const aiScene* scene);//转换为我们自己的Mesh类
	std::vector<Texture> loadMaterialTextures(aiMaterial *mat,aiTextureType type,std::string typeName);//通过类型加载贴图
	GLint TextureFromFile(const char* path, std::string directory);//通过文件路径下载贴图
};

Model.cpp

#include "Model.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
using namespace std;
#include<vector>

Model::Model(std::string path)//构造并加载模型
{
	loadModel(path);
}

void Model::Draw(Shader* shader)
{
	for (unsigned int i = 0; i < meshes.size(); i++)//将获取到网格全部绘制出来
	{
		meshes[i].Draw(shader);
	}
	
}

void Model::loadModel(const std::string path)//通过文件路径加载模型
{
	Assimp::Importer importer;
	//读取obj文件
	const aiScene* scene = importer.ReadFile(path,aiProcess_Triangulate|aiProcess_FlipUVs|aiProcess_CalcTangentSpace);
	if (!scene||scene->mFlags&AI_SCENE_FLAGS_INCOMPLETE||!scene->mRootNode)    //没找到就退出
	{
		std::cout << "ERROR::ASSIMP::" << importer.GetErrorString() << std::endl;
		return;
	}
	//获取到obj文件的所在文件夹地址，如...\model\one.obj,得到就是...\model
	this->directory = path .substr(0, path.find_last_of("\\"));
		processNode(scene->mRootNode,scene);//递归遍历模型的所有节点
}

void Model::processNode(aiNode* node, const aiScene* scene)//递归遍历节点
{
	for (unsigned int i = 0; i < node->mNumMeshes; i++)//遍历当前节点的所有网格，
	{
		aiMesh* curMesh = scene->mMeshes[node->mMeshes[i]];//获取到对应的网格配置
		this->meshes.push_back(processMesh(curMesh,scene));//将网格转换成我们的网格，加到我们的meshes容器里
	}
	for (unsigned int i = 0; i < node->mNumChildren; i++)//递归遍历节点
	{
		processNode(node->mChildren[i],scene);
	}
}
Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene)//转换Mesh类
{
	std::vector<Vertex> vertics;
	std::vector<GLuint>indices;
	std::vector<Texture>textures;

	for (unsigned int i = 0; i < mesh->mNumVertices; i++)
	{
	//交换Vertex值
		Vertex tempVertex;
		tempVertex.Position.x = mesh->mVertices[i].x;
		tempVertex.Position.y = mesh->mVertices[i].y;
		tempVertex.Position.z = mesh->mVertices[i].z;

		tempVertex.Normal.x = mesh->mNormals[i].x;
		tempVertex.Normal.y = mesh->mNormals[i].y;
		tempVertex.Normal.z = mesh->mNormals[i].z;

		if (mesh->mTextureCoords[0])
		{
			tempVertex.TexCoords.x = mesh->mTextureCoords[0][i].x;
			tempVertex.TexCoords.y = mesh->mTextureCoords[0][i].y;
		}
		else
		{
			tempVertex.TexCoords = glm::vec2(0.0f,0.0f);
		}
		vertics.push_back(tempVertex);
	}
//获取所有索引
	for (unsigned int i = 0; i < mesh->mNumFaces; i++)//遍历所有面
	{
		for (unsigned int j = 0; j < mesh->mFaces[i].mNumIndices; j++)//遍历对应面的所有索引
		{
			indices.push_back(mesh->mFaces[i].mIndices[j]);
		}
	}
	
	if (mesh->mMaterialIndex>=0)//材质不为0时，运行
	{

		aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];//获取到aiMesh的当前材质
		std::vector<Texture> diffuseMaps = this->loadMaterialTextures(material,aiTextureType_DIFFUSE,"texture_diffuse");//获取diffuse贴图

		textures.insert(textures.end(),diffuseMaps.begin(),diffuseMaps.end());//插入diffuse贴图
		std::vector<Texture> specularMaps = this->loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");//获取所有specular贴图
		textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());//插入specular贴图
		
	}
	return Mesh(vertics,textures,indices);//转换成我们的Mesh类


}

//获取对应类型的贴图
std::vector<Texture> Model::loadMaterialTextures(aiMaterial* mat, aiTextureType type, std::string typeName)
{

	std::vector < Texture > textures;
	for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)//查看所有对应类型的贴图
	{
		aiString str;
		mat->GetTexture(type,i,&str);//获取贴图
		bool skip = false;
		for (unsigned int j = 0; j < textures_loaded.size(); j++)	//检测是否已经加载过了，如果加载过，就直接获取，避免重复加载
		{
			if (std::strcmp(textures_loaded[j].path.C_Str(), str.C_Str()) == 0	)
			{
				textures.push_back(textures_loaded[j]);
				skip = true; // a texture with the same filepath has already been loaded, continue to next one. (optimization)
				break;
			}
		}
		
		if (!skip)//加载新贴图
		{
			Texture texture;
			texture.id = TextureFromFile(str.C_Str(), this->directory);
			texture.path = str;//str
			texture.type = typeName;
			textures.push_back(texture);
			this->textures_loaded.push_back(texture);//加载进当前函数贴图容器
		}
	
	}
	
	return textures;
}

GLint Model::TextureFromFile( const char* path,std::string directory)//从文件中加载贴图
{
   //配置文件路径
	std::string fileName = std::string(path);
	fileName = directory + '\\' + fileName;
   
	GLuint textureID;
	glGenTextures(1,&textureID);
	int width, height, nrChannels;
	//这就是前面那个LoadImageToGpu的内容，加载贴图。
	unsigned char* image = stbi_load(fileName.c_str(), &width, &height, &nrChannels, 0);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, textureID);
	if(image)
    {
		GLenum format;//判断贴图通道
		if (nrChannels == 1)
			format = GL_RED;
		else if(nrChannels == 3)
			format = GL_RGB;
		else if (nrChannels==4)
			format = GL_RGBA;
			
		glTexImage2D(GL_TEXTURE_2D,0,format,width,height,0,format,GL_UNSIGNED_BYTE,image);
		glGenerateMipmap(GL_TEXTURE_2D);
	
	}
	else
	{
		std::cout << "Error! stbi load fail!" << std::endl;
	}
	glUniform1i(glGetUniformLocation(myShader->ID, "material.diffuse"), 0);
	stbi_image_free(image);

	glBindTexture(GL_TEXTURE_2D, 0);
	return textureID;
}

main.cpp

#include<iostream>
#define GLEW_STATIC
#include <GL/glew.h>
#include<GLFW/glfw3.h>

//#define STB_IMAGE_IMPLEMENTATION
//#include "stb_image.h"

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

#include "Shader.h"
#include "Material.h"
#include "Camera.h"
#include "LightDirectional.h"
#include "LightPoint.h"
#include "LightSpot.h"
#include "Mesh.h"
#include "Model.h"
using namespace std;
#pragma region Model Data
GLfloat vertices[] = {
	// Positions          // Normals           // Texture Coords
	-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
	 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  0.0f,
	 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
	 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
	-0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  1.0f,
	-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,

	-0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
	 0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,
	 0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
	 0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
	-0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,
	-0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,

	-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
	-0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
	-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
	-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
	-0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
	-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,

	 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
	 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
	 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
	 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
	 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
	 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,

	-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
	 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  1.0f,
	 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
	 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
	-0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  0.0f,
	-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,

	-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
	 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,
	 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
	 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
	-0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,
	-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  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)
};
#pragma endregion
#pragma region Input Declare
void ProcessInput(GLFWwindow* window);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);

// Window dimensions
const GLuint WIDTH = 800, HEIGHT = 600;
#pragma region Camera Declare
Camera* myCamera = new Camera(glm::vec3(0, 0, 5.0f), glm::radians(-15.0f), glm::radians(180.0f), glm::vec3(0, 1.0f, 0));
#pragma endregion
#pragma region LightDriection Drclare
LightDirectional myLightD(glm::vec3(10.0f,10.0f,5.0f),glm::vec3(glm::radians(0.0f), glm::radians(0.0f),0),glm::vec3(1.0f,1.0f,1.0f));
#pragma endregion

// The MAIN function, from here we start the application and run the game loop
int main(int argc, char* argv[])
{
	std::string directory = argv[0];
	directory = directory.substr(0, directory.find_last_of("\\")) + "\\Model\\nanosuit.obj";
	#pragma region Open a Window
	// Init GLFW
	glfwInit();
	// Set all the required options for GLFW
	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);

	// Create a GLFWwindow object that we can use for GLFW's functions
	GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	//隐藏鼠标
	glfwSetInputMode(window,GLFW_CURSOR,GLFW_CURSOR_DISABLED);
	//鼠标移动时呼叫mouse_callback函数
	glfwSetCursorPosCallback(window, mouse_callback);


	// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
	glewExperimental = GL_TRUE;
	 Initialize GLEW to setup the OpenGL Function pointers
	glewInit();

	// Define the viewport dimensions
	glViewport(0, 0, WIDTH, HEIGHT);
#pragma endregion 

	Model model(directory);

    #pragma region Create Matrix	
	glm::mat4 viewMat;
	glm::mat4 projMat;
	projMat = glm::perspective(glm::radians(45.0f), (float)WIDTH / (float)HEIGHT, 0.01f, 100.0f);
	glEnable(GL_DEPTH_TEST);
#pragma endregion

    #pragma region Init Shader
	Shader* myShader = new Shader("vertexSource.vert", "fragmentSource.frag");
#pragma endregion
	
	// Game loop
	while (!glfwWindowShouldClose(window))
	{	// 检查事件，调用相应的回调函数，如下文的glfwInput函数
		//Process Input
		ProcessInput(window);
        //Clear screen
		glClearColor(0.3f, 0.3f, 0.3f, 1.0f);//渲染颜色到后台缓冲
		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);//清除前台缓冲
		
		
		viewMat = myCamera->GetViewMatrix();//刷新视角
        for (size_t i = 1; i <= 2; i++)
		{
			glm::mat4 modelMat;//模型矩阵
			modelMat = glm::translate(modelMat, cubePositions[i]);
			modelMat = glm::rotate(modelMat, glm::radians(i*10.0f), glm::vec3(0, 1.0f, 0));
			//Uesd ShaderProgram
			myShader->Use();
			
			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "modelMat"), 1, GL_FALSE, glm::value_ptr(modelMat));
			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "viewMat"), 1, GL_FALSE, glm::value_ptr(viewMat));
			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "projMat"), 1, GL_FALSE, glm::value_ptr(projMat));
			
			glUniform3f(glGetUniformLocation(myShader->ID, "objColor"), 1.0f, 1.0f, 1.0f);
			glUniform3f(glGetUniformLocation(myShader->ID, "ambientColor"), 0.1f, 0.1f, 0.1f);
			glUniform3f(glGetUniformLocation(myShader->ID, "CameraPos"), myCamera->Position.x, myCamera->Position.y, myCamera->Position.z);

			glUniform3f(glGetUniformLocation(myShader->ID, "lightD.color"), myLightD.color.x, myLightD.color.y, myLightD.color.z);
			glUniform3f(glGetUniformLocation(myShader->ID, "lightD.pos"), myLightD.position.x, myLightD.position.y, myLightD.position.z);
			glUniform3f(glGetUniformLocation(myShader->ID, "lightD.dirToLight"), myLightD.direction.x, myLightD.direction.y, myLightD.direction.z);
			
		

			myShader->SetUniform1f("material.shininess", 32);

			model.Draw(myShader);

		}
		
		glfwSwapBuffers(window);
		glfwPollEvents();
	}


	glfwTerminate();
	return 0;
}

#pragma region Input Fuction 
// Is called whenever a key is pressed/released via GLFW
void ProcessInput(GLFWwindow* window)//通过监控鼠标来控制相机的移动
{
	
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
		glfwSetWindowShouldClose(window, GL_TRUE);
	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveZ(1);
	}
	else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveZ( -1);
	}
	else if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveX(1);
	}
	else if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveX(-1);
	}
	else if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveY(1);
	}
	else if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
	{
		myCamera->CameraPosMoveY(-1);
	}
}
bool firstMouse = true;
float lastx = 300, lasty = 400;
void mouse_callback(GLFWwindow* window, double xpos, double ypos)//检查鼠标输入
{
	if (firstMouse==true)//第一次调用该函数的时候直接将当前坐标给过去坐标值，已此来防止一开始的时候出现视角的巨大晃动
	{
		lastx = xpos;
		lasty = ypos;
		firstMouse = false;
	}
	float offsetx = xpos - lastx;
	float offsety = ypos - lasty;
	//std::cout << offsetx << std::endl;
	lastx = xpos;
	lasty = ypos;
	myCamera->CameraViewMove(offsetx,offsety);//调用CameraViewMove函数
}
#pragma endregion

这是效果图：
在这里插入图片描述
最后再记录一个我遇到的问题，被坑了很久，就是如果你的OpenGL加载模型的时候出现了贴图只有灰色的效果。
如下图：
在这里插入图片描述
那就是你的贴图加载通道出了问题。比如这个就是因为模型的贴图为RGBA的，可是我一开始只给了RGB，所以就成了这样。而且这种贴图还是加载成功了的。所以很难排错，所以你以后还是尽量写成那种自动配置颜色通道的会比较好。
就是这句代码：

glTexImage2D(GL_TEXTURE_2D,0, format,width,height,0, format,GL_UNSIGNED_BYTE,image);
永远的小白虾
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
OpenGL学习笔记（三）
龙云尧的博客
05-03 495
第二课和第三课内容为三角形和矩形的颜色渲染内容，通过实例告诉我们如何给实现的样例进行上色。我们已经知道任何在OpenGL中，任何形状都将最终被分解成矩形和三角形两种形状，所以在这两课中我们将对三角形和矩形的构建和渲染进行学习。三角形和矩形构造构建三角形或者矩形的方法在DrawGLScene方法中实现。绘制图像之前我们需要先将屏幕缓存清理掉，即调用glClear和glLoadIdentity。这个时候
OpenGL入门学习笔记（三）
WY的博客
02-19 259
多边形的绘制（一）多边形的两面与其绘制方法从三维的角度来看，一个多边形具有两个面。 每一个面都可以设置不同的绘制方式： 填充; 只绘制边缘轮廓线; 只绘制顶点; 其中“填充”是默认的方式。可以为两个面分别设置不同的方式。 glPolygonMode的原型是:void glPolygonMode(GLenum face,GLenum mode); 用于控制多边形的显示方法。face将确定显示模式
assimp.net
金溪的博客
06-21 5519
Assimp (Open Asset Import Library) Assimp.Net是Assimp的一个封装，使用P/Invoke与Assimp库进行交互，Api可以分为两类： （1） 一组低级函数，表达Assimp的C-API，它是使用AssimpMethods的静态类，这是一个P/Invoke层，需要你从unmanageable memory中整理模型数据，这些在Assimp.Unm...
Assimp库代码存档
略游
10-29 593
个人感觉assimp存在bug，打算替换至tinygltf，所以备份一下代码。
第十三章 opengl之模型（导入3D模型）
最新发布
Re_view的博客
03-09 1442
第十三章 opengl之模型（导入3D模型）
learnOpenGL 2.4 投光物
qq_43533956的博客
09-10 118
多个箱子 创建多个箱子的过程与第一章中类似，下面是主程序中的代码 glm::vec3 cubePositions[] = { ...}; glBindVertexArray(cubeVAO); for (int i = 0; i < 10; i++) { glm::mat4 model = glm::mat4(1.0f); model = glm::translate(model, cubePositions[i]
【OpenGL】笔记十八、利用Assimp加载自定义模型(Model类)
ycrsw的博客
05-30 2129
1.流程 1.1 头文件 经过上节网格类的设置以后，我们现在开始正式接触assimp（上图为其简化结构），加载自己的模型，首先我们要使用assimp，就需要它的头文件： #include <assimp/Importer.hpp> #include <assimp/scene.h> #include <assimp/postprocess.h> 1.2 Model类 其次我们要定义一个Model类，包含一个构造函数用于读取数据，一个Draw函数用于渲染，一个上节定义的
OpenGL with QtWidgets：使用Assimp库加载模型
龚建波
10-20 1599
（本文是LearnOpenGL的学习笔记，教程中文翻译地址https://learnopengl-cn.github.io/（备用地址https://learnopengl-cn.readthedocs.io/zh/latest/），写于 2021-10-19） 0.前言 教程加载模型这一章节主要是讲 Assimp 库的基本使用，所以本文就记录下 Assimp 使用 VS2019 编译，以及在 Qt 中的基本使用。 1.Assimp 下载与编译 源码可以直接去 github 下载（搜 assimp.
svn-importer-1.2.zip
06-30
SVN Importer可以进行CVS版本库到SVN版本库的迁移。
OpenGL 笔记2
贤愚的博客
03-24 183
结构体的uniform设置的名称 "xxx.xxx" uniform是数组则使"xxx[n]" 光源 光源的设置 直射光、点光源、聚光源 代码中主要就是传必要的值给shader #ifndef LIGHT_H #define LIGHT_H #include <glad/glad.h> #include <glm/glm.hpp> #include <...
无法解析的外部符号”private: char * __cdecl cv::String::allocate(unsigned __int64)” (?allocate@String@cv@@AEAA
01-20
1>—— 已启动生成: 项目: save-image, 配置: Release x64 —— 1>save-image-D435.obj : error LNK2001: 无法解析的外部符号 “private: char * __cdecl cv::String::allocate(unsigned __int64)” (?allocate@String@cv@@AEAAPEAD_K@Z) 1>save-image-D435.obj : error LNK2001: 无法解析的外部符号 “private: void __cdecl cv::String::deallocate(void)” (
QT显示LAS激光点云文件
05-05
qt显示LAS文件，用opengl实现旋转平移缩放，有显示界面，QT+OPENGL基本框架，可直接使用。
OpenGL学习笔记十——从建模软件导入复杂模型：Assimp的使用
绿洲守望者
02-17 1137
OpenGL学习笔记十——从建模软件导入复杂模型，使用Assimp 常用建模软件 模型常见格式模型加载库Assimp Assimp编译步骤基础环境 下载链接使用： 常用建模软件 Blender 3DS Max Maya Houdini(可程序化生成模型，非常强大，推荐学习使用） 模型常见格式 .obj（通用格式） .max（max建模软件） .fbx（游戏引擎常用格式） .maya（M...
OpenGL学习总结（五）
xiewenzhao123的博客
01-18 2271
OpenGL模型加载——Assimp1、Assimp模型加载库Assimp全称为Open Asset Import Library，可以导入几十种不同格式的模型文件（同样也可以导出部分模型格式）。只要Assimp加载完了模型文件，我们就可以从Assimp上获取所有我们需要的模型数据。Assimp把不同的模型文件都转换为一个统一的数据结构，所有无论我们导入何种格式的模型文件，都可以用同一个方式去访问我
运用assimp库进行OpenGL模型的加载与转换
stephn1996的博客
06-22 3628
这篇文章将介绍运用assimp库进行实际的模型加载与转换的代码。 #include "assimp\Importer.hpp" #include "assimp\scene.h" #include "assimp\postprocess.h"首先导入assimp库的头文件。 Assimp::Importer importer; const aiScene* scene = importer
3D模型读取库：Assimp
weixin_30881367的博客
08-28 567
Assimp（Open Asset Import Library）是一个支持读取多种模型资源的开源库，当前最新的版本是3.0版，支持读取以下类型的3D模型： Collada ( .dae ) Blender 3D ( .blend ) 3ds Max 3DS ( .3ds ) 3ds Max ASE ( .ase ) Wavefront Object ( .obj ) I...
Android opengl ES 实现后台绘图并保存成bitmap
热门推荐
HellDevil的专栏
04-26 2万+
最近在android 上有个构思，就是如何使用opengl ES在后台绘制个3D图片，然后把这个绘制好的图片保存成bitmap格式。。。想了好几天，也尝试了多种方法，但是都不行，一开始尝试用GLSurfaceView的方式，但是这样会导致我的Activity和渲染的东东发生联系，我想要要的结果是无论如何我的主Acivity都不能和我渲染的图片发生任何关系（也就是说主Acitivity不能显示任何我
Android OpenGLES2.0（十五）——利用EGL后台处理图像
湖广午王
02-20 1万+
在Android OpenGLES2.0（十二）——FBO离屏渲染中，记录了采用FBO进行离屏渲染的方式来进行后台处理图像，但是在使用时，示例中还是用到了GLSurfaceView控件来提供GL环境。怎样完全抛开GLSurfaceView来进行图像处理呢？OpenGLES和EGL OpenGL（全写Open Graphics Library）是指定义了一个跨编程语言、跨平台的编程接口规格的专业的
基于OpenGL的三维模型简化算法研究与实现
本篇硕士论文《基于OpenGL的三维模型简化算法的研究与实现》由湖南大学的信息科学与工程学院学生张非凡于2015年4月30日提交，指导教师包括常炳国副教授和王祥宗高级工程师。论文主要探讨了如何利用OpenGL这一图形库...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值