Assimp库代码存档

最新推荐文章于 2024-04-29 11:56:38 发布
最新推荐文章于 2024-04-29 11:56:38 发布
阅读量562 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ assimp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014629601/article/details/127587557
版权

        个人感觉assimp存在bug，打算替换至tinygltf，所以备份一下代码。

/**
* @file		DND.ModelLoader.ixx
* @brief	模型加载器，基于Assimp库
*
*
* @version	1.0
* @author	lveyou
* @date		22-09-02
*
* @note		由于Assimp库过于庞大，我们只在windows平台使用动态链接库
* @note		Assimp默认为右手坐标系（+X 指向右侧，+Y 指向上方，+Z 指向屏幕外朝向观看者）
* @note		逆时针顶点绕序为正面
* @note		行优先矩阵
*/
#ifdef WIN32

module;
#include <assimp/Importer.hpp>      //C++导入接口
#include <assimp/scene.h>           //输出数据结构
#include <assimp/postprocess.h>     //后处理标志
#include <assimp/IOStream.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/Logger.hpp>
#include <assimp/DefaultLogger.hpp>
#include <assimp/Exceptional.h>		//异常处理
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>

#include "DND.h"
export module DND.ModelLoader;

import DND.Std;
import DND.Type;
import DND.ModelObject;
import DND.Debug;
import DND.String;
import DND.Image;
import DND.File;
import DND.Factory;
import DND.BoneAnimation;
import DND.Math;

namespace dnd 
{

static glm::vec3 vec3_cast(const aiVector3D& v) { return glm::vec3(v.x, v.y, v.z); }
static glm::vec2 vec2_cast(const aiVector3D& v) { return glm::vec2(v.x, v.y); }
static glm::quat quat_cast(const aiQuaternion& q) { return glm::quat(q.w, q.x, q.y, q.z); }
static glm::mat4 mat4_cast(const aiMatrix4x4& m) { return glm::transpose(glm::make_mat4(&m.a1)); }
static glm::mat4 mat4_cast(const aiMatrix3x3& m) { return glm::transpose(glm::make_mat3(&m.a1)); }



}

DND_NAMESPACE_EXPORT

using namespace Assimp;

constexpr uint8_t BONE_ID_NONE = (uint8_t)255;

class ModelLoaderLogStream : public LogStream
{
public:
	//日志
	void write(const char* message) {
		g_debug.Write(format("Assimp：{}", message));
	}
};

class ModelLoader
{

public:
	ModelLoader()
	{
		//日志等级
		const unsigned int severity = 
			Logger::Debugging | Logger::Info 
			| Logger::Err | Logger::Warn;
		DefaultLogger::create("", Logger::VERBOSE);
		//附加到默认logger
		DefaultLogger::get()->attachStream(new ModelLoaderLogStream, severity);
	}
	~ModelLoader()
	{
		DefaultLogger::kill();
	}

	vector<ModelObject*> Load(string_view path_name, string_view res_name)
	{
		string str_path = string{ path_name };
		string str_base = String::EraseFilename(path_name);
		debug(format("开始加载模型文件：{}，{}", str_path, str_base));

		//创建导入类实例
		Assimp::Importer importer;
		const aiScene* scene = importer.ReadFile(str_path,
			aiProcess_CalcTangentSpace |
			aiProcess_Triangulate |
			aiProcess_JoinIdenticalVertices |
			aiProcess_SortByPType |
			aiProcess_FlipUVs);
		//后处理标记
		//aiProcess_MakeLeftHanded 可修改为左手坐标系
		//aiProcess_FlipWindingOrder 修改为顺时针为正面
		//aiProcess_FlipUVs 默认左下角，设置后为左上角
		//aiProcess_GenNormals 生成法线
		//aiProcess_LimitBoneWeights 限制骨骼权重数为4（这个有bug）
		//aiProcess_FindInvalidData 除错一些数据
		//aiProcess_SplitByBoneCount 分割具有多个骨骼的网格
		//aiProcess_GlobalScale 执行全局缩放
		//aiProcess_EmbedTextures 将纹理变为嵌入形式，文件不存在，还会检查根目录同名文件
	
		if (!scene)
		{
			debug_err(format("导入场景失败：{}", importer.GetErrorString()));
			return {};
		}
		//debug_err(importer.GetErrorString());
		debug_msg(format("打开模型文件成功，开始加载模型：{}", path_name));
		debug(format("网格 数：{}", scene->mNumMeshes));
		debug(format("材质 数：{}", scene->mNumMaterials));
		debug(format("贴图 数：{}", scene->mNumTextures));
		debug(format("动画 数：{}", scene->mNumAnimations));

		//有动画则假设有骨骼
		bool has_bone = scene->mNumAnimations;

		//返回结构
		vector<ModelObject*> ret;
		ModelObject* model_object = new ModelObject;
		std::vector<Vertex>& mo_vertices =  model_object->_allVertex;
		std::vector<VertexBone>& mo_vertices_bone = model_object->_allVertexBone;
		std::vector<uint32_t>& mo_indices = model_object->_allIndex;
		vector<ModelObjectMaterial>& mo_material = model_object->_allMaterial;
		
		model_object->_boneData = has_bone ? new BoneData : nullptr;
		BoneData* bone_data = model_object->_boneData;

		ret.push_back(model_object);



		//读取材质（我们不读取DefaultMaterial）
		const char NAME_DEFAULT_MATERIAL[] = "DefaultMaterial";
		bool has_default_material = false;
		for (unsigned i = 0; i < scene->mNumMaterials; ++i)
		{
			const aiMaterial* m = scene->mMaterials[i];
			if (strcmp(m->GetName().C_Str(), NAME_DEFAULT_MATERIAL) == 0)
			{
				has_default_material = true;
				assert(i == 0);//它的id必为0
				continue;
			}

			unsigned count_diffuse = m->GetTextureCount(aiTextureType_DIFFUSE);
			unsigned count_normal = m->GetTextureCount(aiTextureType_NORMALS);

			aiColor3D col_diffuse;
			m->Get(AI_MATKEY_COLOR_DIFFUSE, col_diffuse);
			aiColor3D col_specular;
			m->Get(AI_MATKEY_COLOR_SPECULAR, col_specular);
			float shininess;
			m->Get(AI_MATKEY_SHININESS, shininess);
			//记录
			ModelObjectMaterial material;
			material._materialName = m->GetName().C_Str();
			material._material._diffuseAlbedo = { col_diffuse.r, col_diffuse.g, col_diffuse.b, 1.0f };
			material._material._fresnelR0 = { col_specular.r, col_specular.g, col_specular.b };
			material._material._roughness = ShininessToRoughness(shininess);

			if (count_diffuse)
			{
				_read_texture(scene, res_name, m, aiTextureType_DIFFUSE, str_base, material._pathTexDiffuse);
			}
			if (count_normal)
			{
				_read_texture(scene, res_name, m, aiTextureType_NORMALS, str_base, material._pathTexNormal);
			}
			for (unsigned j = 0; j < m->mNumProperties; ++j)
			{
				const aiMaterialProperty* prop = m->mProperties[j];
				debug(format("材质属性：{}，{}", j, prop->mKey.C_Str()));
			}
			PrintMaterial(material, i);
			mo_material.emplace_back(material);
		}
		//当前mesh的索引下标
		size_t index = 0;
		//当前mesh的起始顶点下标
		size_t offset_vertex = 0;
		//所有Node -> node_id
		unordered_map<const aiNode*, size_t> map_node;

		if (has_bone)
		{
			//读取Node关系（aiNode和网格无关，只是层次关系，如果它是骨骼，则同名）
			//有名字的node，我们分配一个id

			//广度优先遍历
			list<aiNode*> all_node;
			//记录
			map_node[scene->mRootNode] = bone_data->_allNodeParent.size();
			size_t id_parent = -1;
			bone_data->_allNodeParent.push_back(id_parent);
			all_node.push_back(scene->mRootNode);//添加到栈顶
			//直至栈空
			while (!all_node.empty())
			{
				//得到栈顶
				aiNode* node = all_node.front();
				all_node.pop_front();

				assert(map_node.find(node) != map_node.end());
				size_t id_parent = map_node[node];

				//子节点，分配id，设置父节点id，并添加到栈尾
				for (unsigned i = 0; i < node->mNumChildren; ++i)
				{
					aiNode* node_child = node->mChildren[i];
					//分配id
					map_node[node_child] = bone_data->_allNodeParent.size();
					//指向父骨骼
					bone_data->_allNodeParent.push_back(id_parent);
					all_node.push_back(node_child);//添加到栈尾
				}
			}
			//父节点必须在前面
#ifndef NDEBUG
			for (size_t i = 0; i < bone_data->_allNodeParent.size(); ++i)
			{
				if (bone_data->_allNodeParent[i] != -1
					&& bone_data->_allNodeParent[i] >= i)
				{//如果 父id 大于等于 自己
					debug_err(format("节点关系错误：自己{}先于父节点{}出现",
						i, bone_data->_allNodeParent[i]));
				}
			}
#endif
			bone_data->_allBoneOffset.resize(map_node.size(), glm::mat4(1.0f));

			//读取动画
			for (unsigned i = 0; i < scene->mNumAnimations; ++i)
			{
				const aiAnimation* animation = scene->mAnimations[i];
				string ani_name = animation->mName.C_Str();
				if (ani_name.empty())
				{
					ani_name = format("{}#{}", res_name, i);
					debug_msg(format("动画名为空，生成名字为：{}", ani_name));
				}
				debug(format("#{}{:=^32}动画", i, ani_name));
				//每个Channel影响一个node
				assert(animation->mNumChannels && animation->mNumChannels <= map_node.size());
				debug(format("节点数：{}", animation->mNumChannels));
				double tick_per_second;
				if (animation->mTicksPerSecond)
					tick_per_second = animation->mTicksPerSecond;
				else
				{
					tick_per_second = 30;
					debug_warn("动画不存在tick每s值，将使用30！");
				}
				double ani_t = animation->mDuration / tick_per_second;
				debug(format("时长：{}，{}/{}", ani_t, animation->mDuration, tick_per_second));

				//添加一个AnimationClip
				AnimationClip& ani_clip = bone_data->_allAnimation[ani_name];
				//以node的大小，而不是NumChannels
				ani_clip._allBoneKeyFrameMulti.resize(map_node.size());
				ani_clip._t0 = std::numeric_limits<real_time>::max();
				ani_clip._t1 = std::numeric_limits<real_time>::min();

				for (unsigned j = 0; j < animation->mNumChannels; ++j)
				{
					const aiNodeAnim* node_ani = animation->mChannels[j];
					//找到node_id
					aiNode* node = scene->mRootNode->FindNode(node_ani->mNodeName);
					assert(node);
					assert(map_node.find(node) != map_node.end());
					//写入对应node
					BoneKeyFrameMulti& all_key_frame = 
						ani_clip._allBoneKeyFrameMulti[map_node[node]];
					//取最大者
					unsigned num_key = max(max(node_ani->mNumPositionKeys,
						node_ani->mNumRotationKeys), node_ani->mNumRotationKeys);
					debug(format("节点，关键帧：{}，{}", node_ani->mNodeName.C_Str(), num_key));

					all_key_frame._allKeyFrame.resize(num_key);
					for (unsigned x = 0; x < node_ani->mNumPositionKeys; ++x)
					{
						BoneKeyFrame& key_frame = all_key_frame._allKeyFrame[x];
						const aiVectorKey& t = node_ani->mPositionKeys[x];
						if(key_frame._t < 0)
							key_frame._t = t.mTime / tick_per_second;
						key_frame._translation = { t.mValue.x, t.mValue.y, t.mValue.z };
					}
					for (unsigned x = 0; x < node_ani->mNumRotationKeys; ++x)
					{
						BoneKeyFrame& key_frame = all_key_frame._allKeyFrame[x];
						const aiQuatKey& r = node_ani->mRotationKeys[x];
						if (key_frame._t < 0)
							key_frame._t = r.mTime / tick_per_second;
						key_frame._roationQuat = { r.mValue.w, r.mValue.x, r.mValue.y, r.mValue.z };
					}
					for (unsigned x = 0; x < node_ani->mNumScalingKeys; ++x)
					{
						BoneKeyFrame& key_frame = all_key_frame._allKeyFrame[x];
						const aiVectorKey& s = node_ani->mScalingKeys[x];

						if (key_frame._t < 0)
							key_frame._t = s.mTime / tick_per_second;
						key_frame._scaling = { s.mValue.x, s.mValue.y, s.mValue.z };
					}
#ifndef NDEBUG
					//时间检查
					for (BoneKeyFrame& key_frame : all_key_frame._allKeyFrame)
					{
						if (key_frame._t < 0)
						{
							debug_err("有关键帧未读取到时间！");
						}
					}
#endif
					//取上下界作为动画时间
					BoneKeyFrame& kf_beg = all_key_frame._allKeyFrame.front();
					BoneKeyFrame& kf_end = all_key_frame._allKeyFrame.back();
					ani_clip._t0 = min(ani_clip._t0, kf_beg._t);
					ani_clip._t1 = max(ani_clip._t1, kf_end._t);
				}
			}
			//assert(bone_data->_allBoneParent.size() == bone_data->GetBoneSize());
			
			int pause = 3;
		}

		//所有mesh数据都在这里（由于mesh对应1个材质，所以简单生成sub即可
		for (unsigned i = 0; i < scene->mNumMeshes; ++i)
		{
			aiMesh* mesh = scene->mMeshes[i];

			assert(mesh->HasPositions());
			bool has_uv = mesh->HasTextureCoords(0);
			bool has_normal = mesh->HasNormals();
			bool has_tangent = mesh->HasTangentsAndBitangents();

			const aiVector3D POS_ZERO = { 0,0,0 };
			for (unsigned j = 0; j < mesh->mNumVertices; ++j)
			{
				const aiVector3D& pos = mesh->mVertices[j];
				const aiVector3D& uv = has_uv ? mesh->mTextureCoords[0][j] : POS_ZERO;
				const aiVector3D& normal = has_normal ? mesh->mNormals[j] : POS_ZERO;
				const aiVector3D& tangent = has_tangent ? mesh->mTangents[j] : POS_ZERO;
				if (has_bone)
				{
					VertexBone v;
					v._pos = { pos.x, pos.y, pos.z };
					v._uv = { uv.x, uv.y };
					v._normal = { normal.x,normal.y,normal.z };
					v._tangent = { tangent.x, tangent.y, tangent.z };
					v._boneWeight = { 0, 0, 0 };
					for (uint8_t& iter : v._boneID)
						iter = BONE_ID_NONE;//最后需要转换为0
					mo_vertices_bone.emplace_back(v);
				}
				else
				{
					Vertex v;
					v._pos = { pos.x, pos.y, pos.z };
					v._uv = { uv.x, uv.y };
					v._normal = { normal.x,normal.y,normal.z };
					v._tangent = { tangent.x, tangent.y, tangent.z };

					mo_vertices.emplace_back(v);
				}
				
			}

			//以face读取则是索引（为mesh的索引，而不是整体）
			for (unsigned k = 0; k < mesh->mNumFaces; ++k)
			{
				const aiFace& face = mesh->mFaces[k];
				assert(face.mNumIndices == 3);
				mo_indices.push_back((uint32_t)(face.mIndices[0] + offset_vertex));
				mo_indices.push_back((uint32_t)(face.mIndices[1] + offset_vertex));
				mo_indices.push_back((uint32_t)(face.mIndices[2] + offset_vertex));
			}

			ModelObjectSub sub;
			sub._range._offsetIndex = index;
			sub._range._countTriangle = mesh->mNumFaces;
			if (has_default_material)
				sub._indexMaterial = (size_t)mesh->mMaterialIndex - 1;
			else
				sub._indexMaterial = mesh->mMaterialIndex;
			model_object->_allSub.push_back(sub);


			if (has_bone)
			{//读取骨骼
				for (unsigned k = 0; k < mesh->mNumBones; ++k)
				{
					const aiBone* bone = mesh->mBones[k];
					//找到node_id
					aiNode* node = scene->mRootNode->FindNode(bone->mName);
					assert(node);
					assert(map_node.find(node) != map_node.end());
					size_t node_id = map_node[node];

					debug(format("骨骼，下标，节点，顶点：{}，{}，{}，{}",
						bone->mName.C_Str(), k, node_id, bone->mNumWeights));
					//记录偏移矩阵
					bone_data->_allBoneOffset[node_id] = mat4_cast(bone->mOffsetMatrix);
					//写入顶点骨骼相关数据
					for (unsigned m = 0; m < bone->mNumWeights; ++m)
					{
						const aiVertexWeight& weight = bone->mWeights[m];
						if(weight.mWeight == 0)
							continue;//有可能它本身为0
						VertexBone& v = mo_vertices_bone[weight.mVertexId + offset_vertex];
						size_t n = 0;
						for (; n < NUM_BONE; ++n)
						{//写入为255的位置
							if (v._boneID[n] == node_id)
								break;//有可能会重复（冗余）
							if (v._boneID[n] == BONE_ID_NONE)
								break;
						}
						if (n == NUM_BONE)
						{//越界
							debug_warn(format("同一个顶点的骨骼数超过{}，将忽略多余的！", NUM_BONE));
							continue;
						}
						if (n != NUM_BONE - 1)
						{//不是最后一个位置才写入
							v._boneWeight[n] = weight.mWeight;
						}
						else
						{//最后一个进行求和验证
#ifndef NDEBUG
							float sum = v._boneWeight[0] + v._boneWeight[1]
								+ v._boneWeight[2] + weight.mWeight;
							if (abs(sum - 1.0f) > 0.1f)
							{
								debug_err("骨骼权重和不为1！");
								Vector4 v_n = {
							v._boneWeight[0], v._boneWeight[1],
							v._boneWeight[2], weight.mWeight };
								Math::Normalize(v_n);
								v._boneWeight = glm::make_vec3(v_n.data());
							}
#endif
						}
						v._boneID[n] = node_id;
					}
				}
			}

			debug(format("#{}{:=^32}网格", i, mesh->mName.C_Str()));
			debug(format("面数，材质下标：{}，{}", mesh->mNumFaces, mesh->mMaterialIndex));
			debug(format("顶点数：{}", mesh->mNumVertices, has_normal, has_tangent));
			debug(format("法线，切线：{}，{}", has_normal, has_tangent));
			debug(format("起始，三角数：{}，{}", index, mesh->mNumFaces));

			index = mo_indices.size();
			offset_vertex = has_bone ? mo_vertices_bone.size() : mo_vertices.size();
		}
		//记录到父节点矩阵
		if (has_bone)
		{
			bone_data->_allNodeTrans2Parent.resize(map_node.size());
			for (auto& [node, id] : map_node)
			{
				bone_data->_allNodeTrans2Parent[id] = mat4_cast(node->mTransformation);
			}
		}
		//顶点骨骼id置0
		for (VertexBone& v : mo_vertices_bone)
		{
			for (uint8_t& id : v._boneID)
			{
				if (id == BONE_ID_NONE)
					id = 0;
			}
		}
		//子网格合并
		if (true)
		{//合并网格连续，且材质相同的项
			vector<ModelObjectSub> vec_sub;
			ModelObjectSub* pre = nullptr;
			//
			for (auto iter = model_object->_allSub.begin();
				iter != model_object->_allSub.end(); ++iter)
			{
				ModelObjectSub& sub = *iter;

				if (pre
					&& sub._indexMaterial == pre->_indexMaterial
					&& (sub._range._offsetIndex 
						== pre->_range._offsetIndex + pre->_range._countTriangle * 3))
				{//是连续的
					pre->_range._countTriangle += sub._range._countTriangle;
				}
				else
				{
					vec_sub.push_back(sub);
					pre = &vec_sub.back();
				}
			}
			debug(format("子网格合并：{}->{}", model_object->_allSub.size(), vec_sub.size()));
			for (ModelObjectSub& sub : vec_sub)
			{
				debug(format("合并后网格，起始：{}，三角数：{}，材质：{}", 
					sub._range._offsetIndex, sub._range._countTriangle, sub._indexMaterial));
			}

			swap(model_object->_allSub, vec_sub);
			int pause = 3;
		}
		return ret;
	}

private:
	struct SceneObject
	{

	};
	//递归遍历node
	void _process_node(aiNode* node, SceneObject* targetParent, aiMatrix4x4 accTransform)
	{
		SceneObject* parent;
		aiMatrix4x4 transform;

		//如果node有mesh，则创建一个SceneObject
		if (node->mNumMeshes > 0) 
		{
			SceneObject* newObject = new SceneObject;
			//targetParent.addChild(newObject);
			//读取mesh到SceneObject
			_read_node_mesh(node, newObject);

			//这个SceneObject是所有子节点的父亲
			parent = newObject;
			//transform.SetUnity();
		}
		else
		{
			//如果nodem没有mesh，则跳过，但应用变换
			parent = targetParent;
			transform = node->mTransformation * accTransform;
		}

		//继续遍历所有子节点（广度优先）
		for (size_t i = 0; i < node->mNumChildren; ++i)
		{
			_process_node(node->mChildren[i], parent, transform);
		}
	}

	//读取网格
	void _read_node_mesh(aiNode* node, SceneObject* object)
	{

	}
	//光滑度 -> 粗糙度
	float ShininessToRoughness(float Ypoint)
	{
		float a = -1;
		float b = 2;

		float c;
		c = (Ypoint / 100) - 1;

		float D;
		D = b * b - (4 * a * c);

		float x1;
		x1 = (-b + sqrt(D)) / (2 * a);

		return x1;
	}
	//打印材质信息
	void PrintMaterial(const ModelObjectMaterial& m, unsigned i)
	{
		debug(format("#{}{:=^32}材质", i, m._materialName));
		debug(format("漫反射率：{}, {}, {}, {}",
			m._material._diffuseAlbedo[0], m._material._diffuseAlbedo[1],
			m._material._diffuseAlbedo[2], m._material._diffuseAlbedo[3]));
		debug(format("菲涅耳系数：{}, {}, {}",
			m._material._fresnelR0[0], m._material._fresnelR0[1], m._material._fresnelR0[2]));
		debug(format("粗糙度：{}", m._material._roughness));
		debug(format("漫反射贴图：{}", m._pathTexDiffuse));
		debug(format("法线贴图：{}", m._pathTexNormal));
		//debug(format("{:=^32}", ""));
	}

	//读取纹理，处理内嵌文件的情况，返回到str_path
	void _read_texture(const aiScene* scene, string_view res_name, const aiMaterial* m,
		aiTextureType tex_type, string_view str_base, string& str_path)
	{
		aiString path;
		m->GetTexture(tex_type, 0, &path);
		const aiTexture* texture = scene->GetEmbeddedTexture(path.C_Str());
		if (texture)
		{
			if (texture->mHeight == 0)
			{//高为0表示它是文件数据，比如png或dds
				string str_fmt = texture->achFormatHint;
				if (Image::IsSupportFormat(str_fmt, true))
				{
					Buffer buf((byte*)texture->pcData, (size_t)texture->mWidth);
					//使用它的名字避免重复导出
					string ai_name = path.C_Str();
					String::EraseNotFileName(ai_name);
					string str = format("{}{}#{}.{}", 
						g_factory->GetPathTemp(), res_name, ai_name, str_fmt);
					if (g_file->SaveBuffer(buf, str))
						str_path = str;
					else
						debug_warn(format("导出贴图失败：{}", str));
				}
				else
					debug_warn(format("不支持的贴图格式：{}", str_fmt));
			}
			else
			{//为rbga32位数据
				assert(0 && "暂未实现！");
			}
		}
		else
		{
			str_path = format("{}{}", str_base, path.C_Str());
			String::CvtPathSlash(str_path);
		}
	}
};

ModelLoader* g_modelLoader;

DND_NAMESPACE_END

#endif

略游
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编译好的assimp库
08-04
编译好的assimp库，可在vs中使用
OpenGL使用Assimp库加载3d模型
04-23
现代OpenGL，利用Assimp进行3d模型加载的一个Demo，提供了两个3d模型，能很好的加载含纹理的.obj格式的3d模型。博客地址：https://blog.csdn.net/lady_killer9/article/details/89458246
Assimp库 VS2015 2017 x64 debug/release包
02-09
一个非常流行的模型导入库是Assimp，它是Open Asset Import Library（开放的资产导入库）的缩写。Assimp能够导入很多种不同的模型文件格式（并也能够导出部分的格式），它会将所有的模型数据加载至Assimp的通用数据结构中； 本包包含VS2015及2017编译的x64 debug/release版本 没有编译32位版本
OpenGL-使用Assimp加载3d模型
关注网络安全、云原生安全
04-22 8582
目录 加载前的准备 下载并编译Assimp 配置Assimp .dll文件的配置 .lib文件的配置 assimp文件的配置 举个栗子 代码 Mesh.h Model.h main.cpp 注意项 结果截图 资源下载 参考：LearnOpenGL 最终结果 模型1 模型2 注：由于CSDN上传的gif不能超过5兆，所以比较模糊，最后有清晰结果截图。 加...
LearnOpenGL学习笔记—入门06：Transformations
清清！的博客
07-24 2769
LearnOpenGL学习笔记—入门06：变换0 前言1 0 前言 本节笔记对应的内容 变换 在入门01中我们配置好了环境 在入门02中我们可以检测输入并出现一个有颜色的窗口 在入门03中我们初步学习了图形渲染管线，尝试用不同方法画出了三角形和四边形 在入门04（上）中我们学习了shader和GLSL的相关知识，并给图形加上了变换的颜色以及彩色。 在入门04（下）中我们建立自己的shader类，并能够从外部读取shader的内容。 在入门05中我们了解了有关材质的内容 尽管我们现在已经知道了如何创建一个物体
Assimp data structure介绍
wangjing09的专栏
10-20 631
主要内容从原网站翻译过来：链接 Assimp 数据结构 调用 Assimp::Importer::ReadFile,aiImportFile或aiImportFileEx，返回aiScene。作为data的根。 默认下，所有的3D数据是右手坐标系下的，和openGl一致。在D3D这种左右坐标系下，设置flag aiProcess_MakeLeftHanded。 winding-order默...
glm::quat 四元数，坑了一下午
xx780452700的博客
04-13 2209
构造函数问题 使用glm的四元数时，由于构造函数参数问题调试了一下午，一直以为是旋转矩阵出错了，没想到是这么一个不起眼的问题，期间也看了定义，但也只看了定义/(ㄒoㄒ)/~~。 它的成员变量里顺序明明是x,y,z,w，结果到了构造函数里参数顺序就变成了(w,x,y,z)！！！ 使用不熟悉的接口时一定要看注释！看注释！看文档！看文档！看文档！ template <typename T, precision P> struct tquat { enum ctor{null};
OpenGL 四元数旋转
highmiao的博客
12-23 4620
原文链接：OpenGL_3_3_Tutorial_Translation 第十七课：旋转 [TOC] Tags： OpenGL 教程 虽然本课有些超出OpenGL的范围，但是解决了一个常见问题：怎样表示旋转？ 《第三课：矩阵》中，我们了解到矩阵可以让点绕某个轴旋转。矩阵可以简洁地表示顶点的变换，但使用难度较大：例如，从最终结果中获取旋转轴就很麻烦。 本课将展示两种最常见的表示旋转的方法...
引擎开发五： Assimp库及使用
热门推荐
哲学天空的博客
04-27 1万+
  Assimp ：全称为Open Asset Import Library，这是一个模型加载库，可以导入几十种不同格式的模型文件（同样也可以导出部分模型格式）。只要Assimp加载完了模型文件，我们就可以从Assimp上获取所有我们需要的模型数据。Assimp把不同的模型文件都转换为一个统一的数据结构，所有无论我们导入何种格式的模型文件，都可以用同一个方式去访问我们需要的模型数据。 官网地址：h...
OpenGL基础26：Assimp库
加载中...
06-19 2751
一、模型文件 游戏中有很多复杂的模型往往都是美术通过3D建模工具构建出来的，当然不是程序将顶点写死在代码里的，想想看一个简单的人物模型可能就有上千个顶点，这个时候按之前“生成木箱子”的方法肯定就不可行了 从3D模型的设计到最后体现在场景中，整个过程可以分为2个步骤 当使用3D建模工具导出模型文件时，建模工具会自己生成所有的顶点坐标、顶点法线和纹理坐标等信息，这些图像技术细节并不需要美工去处理，美工只需要关心如何构建高品质的模型，所有的技术细节内容都隐藏在里导出的模型文件里。而对于图形开发者，就必...
3d读取库－Assimp库
04-13
该库可以读取不同的常见3D模型文件，例如 Collada, Blend, Obj, X, 3DS, LWO, MD5, MD2, MD3, MDL, MS3D 以及其他的一些格式文件。
Visual Studio 2015 Assimp库文件
07-01
CMake+visual studio 2015编译好的Assimp-3.3.1文件，包括include,assimp.lib以及assimp.dll文件
三维模型格式转换神器-assimp
05-01 6675
前言三维模型格式种类繁多，相互之间的格式转换费时费力。本文介绍一个三维格式转换神器assimp，可以非常简单的实现各种三维模型格式的互相转换。assimp简介Asset-Importer-Lib（简称 assimp）是一个库，用于加载和处理来自各种 3D 数据格式的几何场景。该库不是为速度而设计的，它主要用于从各种来源导入资产一次并将其存储为特定于引擎的格式，以便于轻松快...
opengl 中的 gml 函数库四元素转为旋转矩阵（亲测可用）
码农历险记
03-06 2058
    #include &amp;lt;iostream&amp;gt; #include&amp;lt;glm/glm.hpp&amp;gt; #include&amp;lt;glm/gtc/quaternion.hpp&amp;gt;     #include&amp;lt;glm/common.hpp&amp;gt;     using namespace std;         int main()         { ...
OpenGL学习总结（五）
xiewenzhao123的博客
01-18 2218
OpenGL模型加载——Assimp1、Assimp模型加载库Assimp全称为Open Asset Import Library，可以导入几十种不同格式的模型文件（同样也可以导出部分模型格式）。只要Assimp加载完了模型文件，我们就可以从Assimp上获取所有我们需要的模型数据。Assimp把不同的模型文件都转换为一个统一的数据结构，所有无论我们导入何种格式的模型文件，都可以用同一个方式去访问我
模型加载库 Assimp
sy_liao的专栏
04-06 2754
大家好，接下来将为大家介绍模型加载库 Assimp 。 Assimp 全称为 Open Asset Import Library，可以支持几十种不同格式的模型文件的解析（同样也可以导出部分模型格式），Assimp 本身是 C++ 库，可以跨平台使用。 Assimp 可以将几十种模型文件都转换为一个统一的数据结构，所有无论我们导入何种格式的模型文件，都可以用同一个方式去访问我们需要的模型数据。 ...
OpenGL + glm库实现四元数的旋转
haowenlai2008的博客
04-14 8305
最近在搭小引擎，在节点类里面弄了一个返回模型矩阵的方法，想实现旋转，用欧拉角的方式会发生万向节死锁，所以只好用四元数的方式实现，然而learnOpenGL里只提到了用欧拉角的旋转方法，只好去翻翻glm库的文档了 使用四元数进行旋转需要用到几个库 #include <glm/glm.hpp> #include <glm/gtc/matrix_transform.hpp> #i...
第十三章 opengl之模型（导入3D模型）
Re_view的博客
03-09 1392
第十三章 opengl之模型（导入3D模型）
【C++第三阶段】list容器&排序
最新发布
还有很多需要学习，现在还很菜
04-29 773
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
如何在qt中配置assimp库
01-29
3. 在你的代码中包含 Assimp 头文件，例如： ``` #include <assimp/Importer.hpp> ``` 然后你就可以在你的 Qt 项目中使用 Assimp 库了。 注意：上述步骤是假设你已经成功安装了 Assimp 库，并且已经知道了 Assimp...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值