void bc_mesh_loader::convert_aimaterial(core::bc_content_loading_context& p_context, const aiMaterial& p_aimaterial, game::bc_render_material_description& p_material)
{
auto* l_content_manager = core::bc_get_service< core::bc_content_manager >();
aiColor3D l_diffuse;
bcFLOAT l_alpha = 1;
bcFLOAT l_specular_intensity = 1;
bcFLOAT l_specular_power = 1;
p_aimaterial.Get(AI_MATKEY_COLOR_DIFFUSE, l_diffuse);
p_aimaterial.Get(AI_MATKEY_SHININESS_STRENGTH, l_specular_intensity);
p_aimaterial.Get(AI_MATKEY_SHININESS, l_specular_power);
p_aimaterial.Get(AI_MATKEY_OPACITY, l_alpha);
p_material.m_diffuse = core::bc_vector4f(l_diffuse.r, l_diffuse.g, l_diffuse.b, l_alpha);
p_material.m_specular_intensity = l_specular_intensity;
p_material.m_specular_power = l_specular_power;
aiString l_aistr;
const core::bc_path l_file_path = core::bc_path(p_context.m_file_path.c_str()).set_filename(bcL(""));
if (p_aimaterial.GetTexture(aiTextureType_DIFFUSE, 0, &l_aistr) == aiReturn_SUCCESS)
{
p_material.m_diffuse_map = l_content_manager->load< graphic::bc_texture2d_content >
(
p_context.get_allocator_alloc_type(),
core::bc_path(l_file_path).set_filename(core::bc_to_exclusive_wstring(l_aistr.C_Str()).c_str()).get_path().c_str(),
core::bc_content_loader_parameter(p_context.m_parameter)
);
}
if (p_aimaterial.GetTexture(aiTextureType_NORMALS, 0, &l_aistr) == aiReturn_SUCCESS)
{
p_material.m_normal_map = l_content_manager->load< graphic::bc_texture2d_content >
(
p_context.get_allocator_alloc_type(),
core::bc_path(l_file_path).set_filename(core::bc_to_exclusive_wstring(l_aistr.C_Str()).c_str()).get_path().c_str(),
core::bc_content_loader_parameter(p_context.m_parameter)
);
}
if (p_aimaterial.GetTexture(aiTextureType_SPECULAR, 0, &l_aistr) == aiReturn_SUCCESS)
{
p_material.m_specular_map = l_content_manager->load< graphic::bc_texture2d_content >
(
p_context.get_allocator_alloc_type(),
core::bc_path(l_file_path).set_filename(core::bc_to_exclusive_wstring(l_aistr.C_Str()).c_str()).get_path().c_str(),
core::bc_content_loader_parameter(p_context.m_parameter)
);
}
}
shared_ptr<ModelMaterial> ModelMaterialProcessor::LoadModelMaterial(Model& model, aiMaterial& material)
{
InitializeTextureTypeMappings();
ModelMaterialData modelMaterialData;
aiString name;
material.Get(AI_MATKEY_NAME, name);
modelMaterialData.Name = name.C_Str();
for (TextureType textureType = (TextureType)0; textureType < TextureType::End; textureType = (TextureType)(static_cast<int>(textureType) + 1))
{
aiTextureType mappedTextureType = (aiTextureType)sTextureTypeMappings[textureType];
UINT textureCount = material.GetTextureCount(mappedTextureType);
if (textureCount > 0)
{
vector<string>* textures = new vector<string>();
modelMaterialData.Textures.insert(pair<TextureType, vector<string>*>(textureType, textures));
textures->reserve(textureCount);
for (UINT textureIndex = 0; textureIndex < textureCount; textureIndex++)
{
aiString path;
if (material.GetTexture(mappedTextureType, textureIndex, &path) == AI_SUCCESS)
{
textures->push_back(path.C_Str());
}
}
}
}
return make_shared<ModelMaterial>(model, move(modelMaterialData));
}
void AssimpLoader::fillMaterial(const aiMaterial& mat, Mesh& mesh) const {
aiColor3D aiAmbient;
aiColor3D aiDiffuse;
aiColor3D aiSpecular;
mat.Get(AI_MATKEY_COLOR_AMBIENT, aiAmbient);
mesh.ambient = vec4(aiAmbient.r, aiAmbient.g, aiAmbient.b, 1.0f);
mat.Get(AI_MATKEY_COLOR_DIFFUSE, aiDiffuse);
mesh.diffuse = vec4(aiDiffuse.r, aiDiffuse.g, aiDiffuse.b, 1.0f);
mat.Get(AI_MATKEY_COLOR_SPECULAR, aiSpecular);
mesh.specular = vec4(aiSpecular.r, aiSpecular.g, aiSpecular.b, 1.0f);
}
bool assets::Material::loadFromDisk(const std::string& basePath, const aiMaterial& material, AssetManager& assetManager)
{
for (const auto& pair: {
std::make_pair(0u, aiTextureType_EMISSIVE),
std::make_pair(1u, aiTextureType_AMBIENT),
std::make_pair(2u, aiTextureType_DIFFUSE),
std::make_pair(3u, aiTextureType_SPECULAR),
std::make_pair(4u, aiTextureType_HEIGHT)})
{
aiString texturePath;
material.GetTexture(pair.second, 0, &texturePath, nullptr, nullptr, nullptr, nullptr);
const std::string fullPath = basePath + std::string(texturePath.C_Str());
if (0 < texturePath.length)
textures[pair.first] =
assetManager.getOrCreate<Texture>(std::string(texturePath.C_Str()), fullPath.c_str());
}
aiColor3D emissive, ambient, diffuse, specular;
float shininess;
material.Get(AI_MATKEY_COLOR_EMISSIVE, emissive);
material.Get(AI_MATKEY_COLOR_AMBIENT, ambient);
material.Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
material.Get(AI_MATKEY_COLOR_SPECULAR, specular);
material.Get(AI_MATKEY_SHININESS, shininess);
this->emission = glm::vec4(emissive.r, emissive.g, emissive.b, 1.0f);
this->ambient = glm::vec4(ambient.r, ambient.g, ambient.b, 1.0f);
this->diffuse = glm::vec4(diffuse.r, diffuse.g, diffuse.b, 1.0f);
this->specular = glm::vec4(specular.r, specular.g, specular.b, 1.0f);
this->shininess = shininess;
if (textures[2] && textures[2]->surface)
translucent = textures[2]->surface->format->BytesPerPixel == 4;
return true;
}
