• 【C++】obj模型文件解析（tiny_obj_loader）

    obj模型文件解析

    一、前言

            由于本人打算使用Assimp来加载模型，这里记录一下tinyobjloader库的使用。之前也研究过fbxsdk，除了骨骼动画暂未读取外，代码自认为还算可靠。

            tinyobjloader地址：

    https://github.com/tinyobjloader/tinyobjloader

            而tinyobjloader库只有一个头文件，可以很方便的读取obj文件。支持材质，不过不支持骨骼动画，vulkan官方教程便是使用的它。不过没有骨骼动画还是有很大的局限性，这里只是分享一下怎么读取材质和拆分网格。

     

    二、中间文件

            我抽象了一个ModelObject类表示模型数据，而一个ModelObject包含多个Sub模型，每个Sub模型使用同一材质（有的人称为图元Primitive或DrawCall）。最后我将其保存为文件，这样我的引擎便可直接解析ModelObject文件，而不是再去读obj、fbx等其他文件了。

            这一节可以跳过，下一节是真正使用tinyobjloader库。

    1. //一个文件会有多个ModelObject，一个ModelObject根据材质分为多个ModelSub
    2. //注意ModelSub为一个材质，需要读取时合并网格
    3. class ModelObject
    4. {
    5. 	friend class VK;
    6. public:
    7. 	//从源文件加载模型
    8. 	static vector Create(string_view path_name);
    9.  
    10. 	void Load(string_view path_name);
    11.  
    12. 	//保存到文件
    13. 	void SaveToFile(string_view path_name);
    14.  
    15. private:
    16. 	vector _allSub; //下标减1 为材质，0为没有材质
    17.  
    18. 	vector _allVertex;//顶点缓存
    19. 	vector<uint32_t> _allIndex;//索引缓存
    20.  
    21. 	vector _allMaterial;//所有材质
    22.  
    23. 	//------------------不同格式加载实现--------------------------------
    24. 	//obj
    25. 	static vector _load_obj(string_view path_name);
    26. 	static vector _load_obj_2(string_view path_name);
    27. };

             ModelObjectSub只是表示在索引缓存的一段范围：

    1. //模型三角形范围
    2. struct ModelTriangleRange
    3. {
    4. 	ModelTriangleRange() :
    5. 		_countTriangle{ 0 },
    6. 		_offsetIndex{ 0 }
    7. 	{}
    8.  
    9. 	size_t _countTriangle;
    10. 	size_t _offsetIndex;
    11. };
    12.  
    13. //子模型对象 范围
    14. struct ModelObjectSub
    15. {
    16. 	ModelTriangleRange _range;
    17. };

             而ModelObjectMaterial表示模型材质：

    1. //! 材质
    2. struct Material
    3. {
    4. 	glm::vec4 _diffuseAlbedo;//漫反射率
    5. 	glm::vec3 _fresnelR0;	//菲涅耳系数
    6. 	float _roughness;		//粗糙度
    7. };
    8.  
    9. //模型对象 材质
    10. struct ModelObjectMaterial
    11. {
    12. 	//最后转为Model时，变为可以用的着色器资源
    13. 	Material _material;
    14. 	string _materialName;
    15. 	//路径为空，则表示没有（VK加载时会返回0）
    16. 	string _pathTexDiffuse;
    17. 	string _pathTexNormal;
    18. };

    三、使用

            首先引入头文件：

    1. #define TINYOBJLOADER_IMPLEMENTATION
    2. #include

            接口原型，将obj文件变为多个ModelObject：

    vector ModelObject::_load_obj_2(string_view path_name);

             取得文件名，和文件所在路径（会自动加载路径下的同名mtl文件，里面包含了材质）：

    1. string str_path = string{ path_name };
    2. string str_base = String::EraseFilename(path_name);
    3.  
    4. const char* filename = str_path.c_str();
    5. const char* basepath = str_base.c_str();

             基本数据：

    1. debug(format("开始加载obj文件：{}，{}", filename, basepath));
    2.  
    3. bool triangulate = true;//三角化
    4.  
    5. tinyobj::attrib_t attrib; // 所有的数据放在这里
    6. std::vectorshape_t> shapes;//子模型
    7. std::vectormaterial_t> materials;//材质
    8.  
    9. std::string warn;
    10. std::string err;

            加载并打印一些信息：

    1. bool b_read = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filename,
    2. 	basepath, triangulate);
    3.  
    4. //打印错误
    5. if (!warn.empty())
    6. 	debug_warn(warn);
    7.  
    8. if (!err.empty()) 
    9. 	debug_err(err);
    10.  
    11. if (!b_read)
    12. {
    13. 	debug_err(format("读取obj文件失败：{}", path_name));
    14. 	return {};
    15. }
    16. debug(format("顶点数：{}", attrib.vertices.size() / 3));
    17. debug(format("法线数：{}", attrib.normals.size() / 3));
    18. debug(format("UV数：{}", attrib.texcoords.size() / 2));
    19. debug(format("子模型数：{}", shapes.size()));
    20. debug(format("材质数：{}", materials.size()));

             这将打印以下数据：

             由于obj文件只产生一个ModelObject，我们如下添加一个，并返回顶点、索引、材质等引用，用于后面填充：

    1. //obj只有一个ModelObject
    2. vector ret;
    3.  
    4. ModelObject* model_object = new ModelObject;
    5. std::vector& mo_vertices = model_object->_allVertex;
    6. std::vector<uint32_t>& mo_indices = model_object->_allIndex;
    7. vector& mo_material = model_object->_allMaterial;
    8.  
    9. ret.push_back(model_object);

             首先记录材质信息：

    1. //------------------获取材质-------------------
    2. mo_material.resize(materials.size());
    3. for (size_t i = 0; i < materials.size(); ++i)
    4. {
    5. 	tinyobj::material_t m = materials[i];
    6. 	debug(format("材质：{}，{}", i, m.name));
    7.  
    8. 	ModelObjectMaterial& material = model_object->_allMaterial[i];
    9. 	material._materialName = m.name;
    10.  
    11. 	material._material._diffuseAlbedo = { m.diffuse[0], m.diffuse[1], m.diffuse[2], 1.0f };
    12. 	material._material._fresnelR0 = { m.specular[0], m.specular[1], m.specular[2] };
    13. 	material._material._roughness = ShininessToRoughness(m.shininess);
    14.  
    15. 	if(!m.diffuse_texname.empty())
    16. 		material._pathTexDiffuse = str_base + m.diffuse_texname;
    17. 	if (!m.normal_texname.empty())
    18. 		material._pathTexNormal = str_base + m.normal_texname;
    19. }

             这将产生以下输出：

             然后遍历shape，按材质记录顶点。这里需要注意的是，一个obj文件有多个shape，每个shape由n个三角面组成。而每个三角形拥有独立的材质编号，所以这里按材质分别记录，而不是一般的合并为整体：

    1. //------------------获取模型-------------------
    2.  
    3. //按 材质 放入面的顶点
    4. vectorindex_t>> all_sub;
    5. all_sub.resize(1 + materials.size());//0为默认
    6.  
    7. for (size_t i = 0; i < shapes.size(); i++) 
    8. {//每一个子shape
    9. 	tinyobj::shape_t& shape = shapes[i];
    10. 	size_t num_index = shape.mesh.indices.size();
    11. 	size_t num_face = shape.mesh.num_face_vertices.size();
    12. 	debug(format("读取子模型：{}，{}", i, shape.name));
    13. 	debug(format("索引数：{}；面数：{}", num_index, num_face));
    14.  
    15. 	//当前mesh下标（每个面递增3）
    16. 	size_t index_offset = 0;
    17. 	//每一个面
    18. 	for (size_t j = 0; j < num_face; ++j)
    19. 	{
    20. 		int index_mat = shape.mesh.material_ids[j];//每个面的材质
    21. 		vectorindex_t>& sub_idx = all_sub[1 + index_mat];
    22. 		sub_idx.push_back(shape.mesh.indices[index_offset++]);
    23. 		sub_idx.push_back(shape.mesh.indices[index_offset++]);
    24. 		sub_idx.push_back(shape.mesh.indices[index_offset++]);
    25. 	}
    26. }

            按材质记录顶点的索引（tinyobj::index_t）后，接下来就是读取顶点的实际数据，并防止重复读取：

    1. //生成子模型，并填入顶点
    2. std::unordered_mapindex_t, size_t, hash_idx, equal_idx>
    3. 	uniqueVertices;//避免重复插入顶点
    4. size_t i = 0;
    5. for (vectorindex_t>& sub_idx : all_sub)
    6. {
    7. 	ModelObjectSub sub;
    8. 	sub._range._offsetIndex = i;
    9. 	sub._range._countTriangle = sub_idx.size() / 3;
    10. 	model_object->_allSub.push_back(sub);
    11.  
    12. 	for (tinyobj::index_t& idx : sub_idx)
    13. 	{
    14. 		auto iter = uniqueVertices.find(idx);
    15. 		if (iter == uniqueVertices.end())
    16. 		{
    17. 			Vertex v;
    18. 			//v
    19. 			v._pos[0] = attrib.vertices[idx.vertex_index * 3 + 0];
    20. 			v._pos[1] = attrib.vertices[idx.vertex_index * 3 + 1];
    21. 			v._pos[2] = attrib.vertices[idx.vertex_index * 3 + 2];
    22.  
    23. 			// vt
    24. 			v._texCoord[0] = attrib.texcoords[idx.texcoord_index * 2 + 0];
    25. 			v._texCoord[1] = attrib.texcoords[idx.texcoord_index * 2 + 1];
    26. 			v._texCoord[1] = 1.0f - v._texCoord[1];
    27.  
    28. 			uniqueVertices[idx] = mo_vertices.size();
    29. 			mo_indices.push_back((uint32_t)mo_vertices.size());
    30. 			mo_vertices.push_back(v);
    31. 		}
    32. 		else
    33. 		{
    34. 			mo_indices.push_back((uint32_t)iter->second);
    35. 		}
    36. 		++i;
    37. 	}
    38. }
    39. debug(format("解析obj模型完成：v{}，i{}", mo_vertices.size(), mo_indices.size()));
    40. return ret;

             上面用到的哈希函数：

    1. struct equal_idx
    2. {
    3. 	bool operator()(const tinyobj::index_t& a, const tinyobj::index_t& b) const
    4. 	{
    5. 		return a.vertex_index == b.vertex_index
    6. 			&& a.texcoord_index == b.texcoord_index
    7. 			&& a.normal_index == b.normal_index;
    8. 	}
    9. };
    10.  
    11. struct hash_idx 
    12. {
    13. 	size_t operator()(const tinyobj::index_t& a) const
    14. 	{
    15. 		return ((a.vertex_index
    16. 			^ a.texcoord_index << 1) >> 1)
    17. 			^ (a.normal_index << 1);
    18. 	}
    19. };

            最后打印出来的数据如下：

            对于材质的处理，漫反射贴图即是基本贴图，而法线（凹凸）贴图、漫反射率、菲涅耳系数、光滑度等需要渲染管线支持并与光照计算产生效果。

    四、完整代码

            可以此处获取最新的源码（我会改用Assimp，并添加骨骼动画、Blinn-Phong光照模型），也可以用后面的：DND/src/DND.ModelObject.cpp · 略游/DND - Gitee.com

            如果有用，欢迎点赞、收藏、关注，我将更新更多C++相关的文章。

    1. #define TINYOBJLOADER_IMPLEMENTATION
    2. #include 
    3.  
    4. struct equal_idx
    5. {
    6. 	bool operator()(const tinyobj::index_t& a, const tinyobj::index_t& b) const
    7. 	{
    8. 		return a.vertex_index == b.vertex_index
    9. 			&& a.texcoord_index == b.texcoord_index
    10. 			&& a.normal_index == b.normal_index;
    11. 	}
    12. };
    13.  
    14. struct hash_idx 
    15. {
    16. 	size_t operator()(const tinyobj::index_t& a) const
    17. 	{
    18. 		return ((a.vertex_index
    19. 			^ a.texcoord_index << 1) >> 1)
    20. 			^ (a.normal_index << 1);
    21. 	}
    22. };
    23.  
    24. float ShininessToRoughness(float Ypoint)
    25. {
    26. 	float a = -1;
    27. 	float b = 2;
    28.  
    29. 	float c;
    30. 	c = (Ypoint / 100) - 1;
    31.  
    32. 	float D;
    33. 	D = b * b - (4 * a * c);
    34.  
    35. 	float x1;
    36. 	x1 = (-b + sqrt(D)) / (2 * a);
    37.  
    38. 	return x1;
    39. }
    40.  
    41. vector ModelObject::_load_obj_2(string_view path_name)
    42. {
    43. 	string str_path = string{ path_name };
    44. 	string str_base = String::EraseFilename(path_name);
    45.  
    46. 	const char* filename = str_path.c_str();
    47. 	const char* basepath = str_base.c_str();
    48. 	bool triangulate = true;
    49.  
    50. 	debug(format("开始加载obj文件：{}，{}", filename, basepath));
    51.  
    52. 	tinyobj::attrib_t attrib; // 所有的数据放在这里
    53. 	std::vectorshape_t> shapes;//子模型
    54. 	std::vectormaterial_t> materials;
    55.  
    56. 	std::string warn;
    57. 	std::string err;
    58.  
    59. 	bool b_read = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filename,
    60. 		basepath, triangulate);
    61.  
    62. 	//打印错误
    63. 	if (!warn.empty())
    64. 		debug_warn(warn);
    65.  
    66. 	if (!err.empty()) 
    67. 		debug_err(err);
    68.  
    69. 	if (!b_read)
    70. 	{
    71. 		debug_err(format("读取obj文件失败：{}", path_name));
    72. 		return {};
    73. 	}
    74. 	debug(format("顶点数：{}", attrib.vertices.size() / 3));
    75. 	debug(format("法线数：{}", attrib.normals.size() / 3));
    76. 	debug(format("UV数：{}", attrib.texcoords.size() / 2));
    77. 	debug(format("子模型数：{}", shapes.size()));
    78. 	debug(format("材质数：{}", materials.size()));
    79.  
    80. 	//obj只有一个ModelObject
    81. 	vector ret;
    82. 	ModelObject* model_object = new ModelObject;
    83. 	std::vector& mo_vertices = model_object->_allVertex;
    84. 	std::vector<uint32_t>& mo_indices = model_object->_allIndex;
    85. 	vector& mo_material = model_object->_allMaterial;
    86. 	ret.push_back(model_object);
    87.  
    88. 	//------------------获取材质-------------------
    89. 	mo_material.resize(materials.size());
    90. 	for (size_t i = 0; i < materials.size(); ++i)
    91. 	{
    92. 		tinyobj::material_t m = materials[i];
    93. 		debug(format("材质：{}，{}", i, m.name));
    94.  
    95. 		ModelObjectMaterial& material = model_object->_allMaterial[i];
    96. 		material._materialName = m.name;
    97.  
    98. 		material._material._diffuseAlbedo = { m.diffuse[0], m.diffuse[1], m.diffuse[2], 1.0f };
    99. 		material._material._fresnelR0 = { m.specular[0], m.specular[1], m.specular[2] };
    100. 		material._material._roughness = ShininessToRoughness(m.shininess);
    101.  
    102. 		if(!m.diffuse_texname.empty())
    103. 			material._pathTexDiffuse = str_base + m.diffuse_texname;
    104. 		if (!m.normal_texname.empty())//注意这里凹凸贴图（bump_texname）更常见
    105. 			material._pathTexNormal = str_base + m.normal_texname;
    106. 	}
    107.  
    108. 	//------------------获取模型-------------------
    109. 	
    110. 	//按 材质 放入面的顶点
    111. 	vectorindex_t>> all_sub;
    112. 	all_sub.resize(1 + materials.size());//0为默认
    113.  
    114. 	for (size_t i = 0; i < shapes.size(); i++) 
    115. 	{//每一个子shape
    116. 		tinyobj::shape_t& shape = shapes[i];
    117. 		size_t num_index = shape.mesh.indices.size();
    118. 		size_t num_face = shape.mesh.num_face_vertices.size();
    119. 		debug(format("读取子模型：{}，{}", i, shape.name));
    120. 		debug(format("索引数：{}；面数：{}", num_index, num_face));
    121.  
    122. 		//当前mesh下标（每个面递增3）
    123. 		size_t index_offset = 0;
    124. 		//每一个面
    125. 		for (size_t j = 0; j < num_face; ++j)
    126. 		{
    127. 			int index_mat = shape.mesh.material_ids[j];//每个面的材质
    128. 			vectorindex_t>& sub_idx = all_sub[1 + index_mat];
    129. 			sub_idx.push_back(shape.mesh.indices[index_offset++]);
    130. 			sub_idx.push_back(shape.mesh.indices[index_offset++]);
    131. 			sub_idx.push_back(shape.mesh.indices[index_offset++]);
    132. 		}
    133. 	}
    134. 	//生成子模型，并填入顶点
    135. 	std::unordered_mapindex_t, size_t, hash_idx, equal_idx>
    136. 		uniqueVertices;//避免重复插入顶点
    137. 	size_t i = 0;
    138. 	for (vectorindex_t>& sub_idx : all_sub)
    139. 	{
    140. 		ModelObjectSub sub;
    141. 		sub._range._offsetIndex = i;
    142. 		sub._range._countTriangle = sub_idx.size() / 3;
    143. 		model_object->_allSub.push_back(sub);
    144.  
    145. 		for (tinyobj::index_t& idx : sub_idx)
    146. 		{
    147. 			auto iter = uniqueVertices.find(idx);
    148. 			if (iter == uniqueVertices.end())
    149. 			{
    150. 				Vertex v;
    151. 				//v
    152. 				v._pos[0] = attrib.vertices[idx.vertex_index * 3 + 0];
    153. 				v._pos[1] = attrib.vertices[idx.vertex_index * 3 + 1];
    154. 				v._pos[2] = attrib.vertices[idx.vertex_index * 3 + 2];
    155.  
    156. 				// vt
    157. 				v._texCoord[0] = attrib.texcoords[idx.texcoord_index * 2 + 0];
    158. 				v._texCoord[1] = attrib.texcoords[idx.texcoord_index * 2 + 1];
    159. 				v._texCoord[1] = 1.0f - v._texCoord[1];
    160.  
    161. 				uniqueVertices[idx] = mo_vertices.size();
    162. 				mo_indices.push_back((uint32_t)mo_vertices.size());
    163. 				mo_vertices.push_back(v);
    164. 			}
    165. 			else
    166. 			{
    167. 				mo_indices.push_back((uint32_t)iter->second);
    168. 			}
    169. 			++i;
    170. 		}
    171. 	}
    172. 	debug(format("解析obj模型完成：v{}，i{}", mo_vertices.size(), mo_indices.size()));
    173. 	return ret;
    174. }

  • 相关阅读:
    3.1.OpenCV技能树--二值图像处理--阈值
    【愚公系列】2022年11月 .NET CORE工具案例-.NET 7中的WebTransport通信
    HTB-Irked
    7-3 LVS+Keepalived集群叙述与部署
    Jmeter性能实战之分布式压测
    5 Dijkstra算法的设计--来源王英S同学
    Oracle数据库：使用 bash脚本 + 定时任务 自动备份数据
    Git常用命令汇总
    java计算机毕业设计微服务的高校二手交易平台源程序+mysql+系统+lw文档+远程调试
    精简scrapy日志冗余占较大内存
  • 原文地址：https://blog.csdn.net/u014629601/article/details/126663528