Model.cpp

#include "Model.h"
#include "Shader.h"

void Model::Render(Shader& shader)
{
	for (unsigned int i = 0; i < this->meshes.size(); i++)
	{
		this->meshes[i].Render(shader);
	}
}

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 (strcmp(textures_loaded[j].path.data, str.C_Str()) == 0)
			{
				textures.push_back(textures_loaded[j]);
				skip = true;
				break;
			}
		}
		if (!skip)
		{
			Texture texture;
			texture.id = TextureFromFile(str.C_Str(), this->directory, true);
			texture.type = typeName;
			texture.path = str;
			textures.push_back(texture);
			textures_loaded.push_back(texture);
		}
	}
	return textures;
}

void Model::loadModel(std::string path)
{
	this-> scene = this->importer.ReadFile(path, aiProcess_Triangulate);

	// Load Faild
	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
	{
		std::cerr << "ERROR::MODEL::LOADMODEL::FAILD_TO_LOAD_MODEL:" << importer.GetErrorString() << "\n";
		return;
	}
	this->directory = path.substr(0, path.find_last_of('/'));

	processNode(scene->mRootNode, scene);
}

unsigned int Model::TextureFromFile(const char* path, const std::string& directory, bool gamma)
{
	if (path[0] == '*') // Need to load from memory
	{
		unsigned int index = std::stoi(&path[1]);
		const aiTexture* embeddedTexture = this->scene->mTextures[index];

		if (embeddedTexture && embeddedTexture->pcData)
		{
			unsigned int textureID;
			glGenTextures(1, &textureID);
			glBindTexture(GL_TEXTURE_2D, textureID);
			stbi_set_flip_vertically_on_load(true);

			std::cout << "尝试从内存加载纹理，索引: " << index << std::endl;
			std::cout << "数据大小: " << embeddedTexture->mWidth << " 格式: " << embeddedTexture->achFormatHint << std::endl;

			int width, height, nrChannels;
			unsigned char* data = stbi_load_from_memory(
				(const stbi_uc*)embeddedTexture->pcData,
				embeddedTexture->mWidth,
				&width, &height, &nrChannels, 0
			);

			if (data)
			{
				std::cout << "内存纹理加载成功: " << width << "x" << height << " 通道: " << nrChannels << std::endl;
				glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

				GLenum format = 0;
				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, data);
				glGenerateMipmap(GL_TEXTURE_2D);

				// Use mirror-put mode
				/*glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);*/
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
				// Use Nearest filter when smaller
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
				// Use Linear filter when bigger
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

			}
			else
			{
				std::cerr << "Faild to load image!" << "\n";
				// glfwTerminate();
				return 0;
			}

			// free
			stbi_image_free(data);
			return textureID;
		}
	}
	else  // Need to load from src
	{
		std::string filename = std::string(path);
		filename = directory + "/" + filename;

		// Load Image
		unsigned int textureID;
		glGenTextures(1, &textureID);
		glBindTexture(GL_TEXTURE_2D, textureID);

		int width = 0, height = 0, nrChannels = 0;
		stbi_set_flip_vertically_on_load(true);
		unsigned char* data = stbi_load(filename.c_str(), &width, &height, &nrChannels, 0);

		if (data)
		{
			glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

			GLenum format = 0;
			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, data);
			glGenerateMipmap(GL_TEXTURE_2D);

			// Use mirror-put mode
		/*	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);*/
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
			// Use Nearest filter when smaller
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
			// Use Linear filter when bigger
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		}
		else
		{
			std::cerr << "Faild to load image!" << "\n";
			// glfwTerminate();
			return 0;
		}

		// free
		stbi_image_free(data);
		return textureID;
	}
	return 0;
}

void Model::processNode(aiNode* node, const aiScene* scene)
{
	for (unsigned int i = 0; i < node->mNumMeshes; i++)
	{
		// Real Meshes Data
		aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
		// processMesh: return a Mesh object
		this->meshes.push_back(processMesh(mesh, scene));
	}
	// Process child node
	for (unsigned int i = 0; i < node->mNumChildren; i++)
	{
		processNode(node->mChildren[i], scene);
	}
}

Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene)
{
	std::vector<Vertex> vertices;
	std::vector<unsigned int> indices;
	std::vector<Texture> textures;
	// Process vertices
	for (unsigned int i = 0; i < mesh->mNumVertices; i++)
	{
		Vertex vertex = { glm::vec3(0.0f, 0.0f, 0.0f )};
		// Process positons, Normal and Texture coords
		vertex.Position = glm::vec3(
			mesh->mVertices[i].x, 
			mesh->mVertices[i].y, 
			mesh->mVertices[i].z
		);
		vertex.Normal = glm::vec3(
			mesh->mNormals[i].x,
			mesh->mNormals[i].y,
			mesh->mNormals[i].z
		);
		if (mesh->mTextureCoords[0]) // Has Data
		{
			vertex.TexCoords = glm::vec2(
				mesh->mTextureCoords[0][i].x,
				mesh->mTextureCoords[0][i].y
			);
		}
		else //No Data
		{
			vertex.TexCoords = glm::vec2(0.0f, 0.0f);
			std::cout << "No UV!" << "\n";
		}

		vertices.push_back(vertex);
	}

	// Process indices
	for (unsigned int i = 0; i < mesh->mNumFaces; i++)
	{
		aiFace face = mesh->mFaces[i];
		for (unsigned int j = 0; j < face.mNumIndices; j++)
			indices.push_back(face.mIndices[j]);
	}

	// Process textures
	if (mesh->mMaterialIndex < scene->mNumMaterials)
	{
		aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
		std::cout << "===== 材质调试信息 =====" << std::endl;
		std::cout << "材质索引: " << mesh->mMaterialIndex << std::endl;
		std::cout << "漫反射(BASE_COLOR): " << material->GetTextureCount(aiTextureType_BASE_COLOR) << std::endl;
		std::cout << "漫反射(DIFFUSE):    " << material->GetTextureCount(aiTextureType_DIFFUSE) << std::endl;
		std::cout << "高光(SPECULAR):     " << material->GetTextureCount(aiTextureType_SPECULAR) << std::endl;
		std::cout << "法线(NORMALS):      " << material->GetTextureCount(aiTextureType_NORMALS) << std::endl;
		std::cout << "金属度(METALNESS):  " << material->GetTextureCount(aiTextureType_METALNESS) << std::endl;
		std::cout << "粗糙度(ROUGHNESS):  " << material->GetTextureCount(aiTextureType_DIFFUSE_ROUGHNESS) << std::endl;
		std::cout << "环境光遮蔽(AO):     " << material->GetTextureCount(aiTextureType_AMBIENT_OCCLUSION) << std::endl;
		std::cout << "不透明度(OPACITY):  " << material->GetTextureCount(aiTextureType_OPACITY) << std::endl;
		std::cout << "========================" << std::endl;
		std::vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_BASE_COLOR, "texture_diffuse");
		/*std::vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");*/
		textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());

		std::vector<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
		textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());

	}
	return Mesh(vertices, indices, textures);
}