//Setting Objects and Material Paths --------------------
void OnPreprocessModel()
{
// Clean the list of materials
MatList = new List <B2U_MatPath>();
if (assetPath.Contains(B2U_Importer.prefixPrefab))
{
ModelImporter modelImporter = assetImporter as ModelImporter;
modelImporter.materialLocation = ModelImporterMaterialLocation.External;
modelImporter.materialName = ModelImporterMaterialName.BasedOnMaterialName;
modelImporter.materialSearch = ModelImporterMaterialSearch.Everywhere;
string b2upref = Path.ChangeExtension(assetPath, "b2up");
string correct_nameprefab = Path.GetFileName(b2upref);
string prefab_path = "Assets/" + B2U_Importer.metaDataPath + "Prefabs/" + correct_nameprefab;
// Keep Materials and correct paths in a list
XmlDocument doc = new XmlDocument();
doc.Load(prefab_path);
XmlNode root = doc.DocumentElement;
XmlNodeList Materials = root.SelectSingleNode("Materials").ChildNodes;
// UV2 Generation
string uv2 = root.SelectSingleNode("UV2").InnerText;
if (uv2 == "True")
{
modelImporter.generateSecondaryUV = true;
modelImporter.secondaryUVPackMargin = 10.0f;
}
else
{
modelImporter.generateSecondaryUV = false;
}
for (int i = 0; i < Materials.Count; i++)
{
string path = Materials[i].SelectSingleNode("Path").InnerText;
string name = Materials[i].SelectSingleNode("Name").InnerText;
// Creates a Generic material
Material mat = new Material(Shader.Find("Standard"));
mat.name = name;
B2U_MatPath matpath = new B2U_MatPath(mat, path);
MatList.Add(matpath);
}
}
}
// Import and Set Materials -----------------------------
Material OnAssignMaterialModel(Material material, Renderer renderer)
{
// Find this material
string path_mat = "";
string path_mat_xml = "";
for (int i = 0; i < MatList.Count; i++)
{
B2U_MatPath Mat = MatList[i];
if (Mat == null) // Previne erros quando a variável possui lixo ou foi removido pela Garbage Collector
{
MatList.RemoveAt(i);
}
else
{
if (Mat._Mat.name == material.name)
{
path_mat = Mat._Path + "/" + material.name + ".mat";
path_mat_xml = "Assets/" + B2U_Importer.metaDataPath + "Materials/" + material.name + ".b2mat";
}
}
}
// Create/Reimport B2U Material
if (path_mat != "")
{
// Configure the Material based on XML file
XmlDocument mat_xml = new XmlDocument();
mat_xml.Load(path_mat_xml);
XmlNode mat_xml_root = mat_xml.DocumentElement;
Shader shader_name = Shader.Find(mat_xml_root.SelectSingleNode("Shader").InnerText);
//XmlNode mode = mat_xml_root.SelectSingleNode("MaterialMode");
// If it's a not valid shader use the B2U error material
if (shader_name == null)
{
Debug.LogWarning(mat_xml_root.SelectSingleNode("Shader").InnerText);
Debug.LogWarning(shader_name);
Debug.LogWarning("B2U Process: The material " + path_mat + " has not a valid shader name. The Default Error Material will be used to your convenience");
Material errorMat = (Material)AssetDatabase.LoadAssetAtPath("Assets/B2U/Editor/UI/Error.mat", typeof(Material));
return(errorMat);
}
bool rewrite = ((mat_xml_root.SelectSingleNode("Rewrite").InnerText == "True") ? true : false);
Material mat;
bool updateProperties = false;
// Se tiver um material com esse nome
if (AssetDatabase.LoadAssetAtPath(path_mat, typeof(Material)))
{
// Se estiver marcado para ser atualizado
if (rewrite)
{
// Marca para atualizar
updateProperties = true;
mat = AssetDatabase.LoadAssetAtPath(path_mat, typeof(Material)) as Material;
mat.shader = shader_name;
}
// Tem o material, mas não está marcado para atualizar, só usa o mesmo
else
{
return(AssetDatabase.LoadAssetAtPath(path_mat, typeof(Material)) as Material);
}
}
// O material ainda não existe
else
{
updateProperties = true;
material.shader = shader_name;
AssetDatabase.CreateAsset(material, path_mat);
mat = material;
}
if (updateProperties)
{
// Set Keywords
mat.EnableKeyword("_NORMALMAP");
mat.EnableKeyword("_EMISSION");
mat.EnableKeyword("_METALLICGLOSSMAP");
mat.EnableKeyword("_SPECGLOSSMAP");
// Get Data from Channels when available
XmlNode channels = mat_xml_root.SelectSingleNode("Channels");
// Base Color
if (B2U_Utils.getXMLChannel(channels, "_Color") != "null")
{
Color baseColorFromData = B2U_Utils.parseColorChannel(channels.SelectSingleNode("_Color").InnerText);
mat.SetColor("_Color", baseColorFromData);
mat.SetColor("_BaseColor", baseColorFromData); // URP Unlit
mat.SetColor("_UnlitColor", baseColorFromData); // HDRP Unlit
}
// Albedo
if (B2U_Utils.getXMLChannel(channels, "_MainTex") != "null")
{
Texture baseAlbedoFromData = B2U_Utils.parseTextureChannel(channels.SelectSingleNode("_MainTex").InnerText);
if (baseAlbedoFromData)
{
mat.SetTexture("_MainTex", baseAlbedoFromData);
mat.SetTexture("_BaseMap", baseAlbedoFromData); // URP Unlit
mat.SetTexture("_UnlitColorMap", baseAlbedoFromData); //HDRP Unlit
mat.SetFloat("_UseColorMap", 1.0f); // URP Autodesk
}
else
{
mat.SetTexture("_MainTex", null);
mat.SetTexture("_BaseMap", null); // URP Unlit
mat.SetTexture("_UnlitColorMap", null); // HDRP Unlit
mat.SetFloat("_UseColorMap", 0.0f); // URP Autodesk
}
}
// Metallic
if (B2U_Utils.getXMLChannel(channels, "_MetallicGlossMap") != "null" &&
B2U_Utils.getXMLChannel(channels, "_Metallic") != "null")
{
Texture baseMetallicFromData = B2U_Utils.parseTextureChannel(channels.SelectSingleNode("_MetallicGlossMap").InnerText);
if (baseMetallicFromData)
{
mat.SetTexture("_MetallicGlossMap", baseMetallicFromData);
mat.SetFloat("_UseMetalicMap", 1.0f); // URP Autodesk
}
else
{
mat.SetTexture("_MetallicGlossMap", null);
float baseMetallicFloatFromData = B2U_Utils.parseFloatChannel(channels.SelectSingleNode("_Metallic").InnerText);
mat.SetFloat("_Metallic", baseMetallicFloatFromData);
mat.SetFloat("_UseMetalicMap", 0.0f); // URP Autodesk
}
}
// Roughness
Texture baseRoughnessFromData = B2U_Utils.parseTextureChannel(channels.SelectSingleNode("_SpecGlossMap").InnerText);
if (baseRoughnessFromData)
{
mat.SetTexture("_SpecGlossMap", baseRoughnessFromData);
mat.SetFloat("_UseRoughnessMap", 1.0f); // URP Autodesk
}
else
{
mat.SetTexture("_SpecGlossMap", null);
float baseRoughnessFloatFromData = B2U_Utils.parseFloatChannel(channels.SelectSingleNode("_Glossiness").InnerText);
mat.SetFloat("_Glossiness", baseRoughnessFloatFromData);
mat.SetFloat("_UseRoughnessMap", 0.0f); // URP Autodesk
}
// Normal Map
Texture baseNormalFromData = B2U_Utils.parseTextureChannel(channels.SelectSingleNode("_BumpMap").InnerText);
if (baseNormalFromData)
{
mat.SetTexture("_BumpMap", baseNormalFromData);
}
else
{
mat.SetTexture("_BumpMap", null);
}
// Emission
Texture baseEmissionFromData = B2U_Utils.parseTextureChannel(channels.SelectSingleNode("_EmissionMap").InnerText);
if (baseEmissionFromData)
{
mat.SetColor("_EmissionColor", new Color(1, 1, 1));
mat.SetTexture("_EmissionMap", baseEmissionFromData);
}
else
{
mat.SetTexture("_EmissionMap", null);
Color baseEmissionColorFromData = B2U_Utils.parseColorChannel(channels.SelectSingleNode("_EmissionColor").InnerText);
mat.SetColor("_EmissionColor", baseEmissionColorFromData);
}
// Transparent
string value = channels.SelectSingleNode("_Transparent").InnerText;
if (value == "OPAQUE")
{
mat.SetFloat("_Mode", 0.0f);
}
if (value == "CLIP")
{
mat.SetFloat("_Mode", 1.0f);
}
if (value == "BLEND")
{
mat.SetFloat("_Mode", 2.0f);
}
}
return(mat);
}
else
{
// Default Importer
return(null);
}
}
