/// <summary>
/// Converts a Unity material to a glTF material.
/// </summary>
/// <param name="uMaterial">Source material</param>
/// <param name="material">Resulting material</param>
/// <param name="gltf">Associated IGltfWriter. Is used for adding images and textures.</param>
/// <param name="logger">Logger used for reporting</param>
/// <returns>True if no errors occured, false otherwise</returns>
public override bool ConvertMaterial(UnityEngine.Material uMaterial, out Material material, IGltfWritable gltf, ICodeLogger logger)
{
var success = true;
material = new Material {
name = uMaterial.name,
pbrMetallicRoughness = new PbrMetallicRoughness {
metallicFactor = 0,
roughnessFactor = 1.0f
}
};
SetAlphaModeAndCutoff(uMaterial, material);
material.doubleSided = IsDoubleSided(uMaterial);
if (uMaterial.IsKeywordEnabled(k_KeywordEmission))
{
if (uMaterial.HasProperty(k_EmissionColor))
{
var emissionColor = uMaterial.GetColor(k_EmissionColor);
// Clamp emissionColor to 0..1
var maxFactor = math.max(emissionColor.r, math.max(emissionColor.g, emissionColor.b));
if (maxFactor > 1f)
{
emissionColor.r /= maxFactor;
emissionColor.g /= maxFactor;
emissionColor.b /= maxFactor;
// TODO: use maxFactor as emissiveStrength (KHR_materials_emissive_strength)
}
material.emissive = emissionColor;
}
if (uMaterial.HasProperty(k_EmissionMap))
{
var emissionTex = uMaterial.GetTexture(k_EmissionMap);
if (emissionTex != null)
{
if (emissionTex is Texture2D)
{
material.emissiveTexture = ExportTextureInfo(emissionTex, gltf);
if (material.emissiveTexture != null)
{
ExportTextureTransform(material.emissiveTexture, uMaterial, k_EmissionMap, gltf);
}
}
else
{
logger?.Error(LogCode.TextureInvalidType, "emission", material.name);
success = false;
}
}
}
}
if (
uMaterial.HasProperty(k_BumpMap) &&
(uMaterial.IsKeywordEnabled(Materials.Constants.kwNormalMap) ||
uMaterial.IsKeywordEnabled(k_KeywordBumpMap))
)
{
var normalTex = uMaterial.GetTexture(k_BumpMap);
if (normalTex != null)
{
if (normalTex is Texture2D)
{
material.normalTexture = ExportNormalTextureInfo(normalTex, uMaterial, gltf);
if (material.normalTexture != null)
{
ExportTextureTransform(material.normalTexture, uMaterial, k_BumpMap, gltf);
}
}
else
{
logger?.Error(LogCode.TextureInvalidType, "normal", uMaterial.name);
success = false;
}
}
}
var isPbrMetallicRoughness = IsPbrMetallicRoughness(uMaterial);
var needsMetalRoughTexture =
isPbrMetallicRoughness &&
(
HasMetallicGlossMap(uMaterial) ||
uMaterial.IsKeywordEnabled(k_KeywordSmoothnessTextureAlbedoChannelA)
);
OrmImageExport ormImageExport = null;
var mainTexProperty = k_MainTex;
if (uMaterial.HasProperty(k_BaseMap))
{
mainTexProperty = k_BaseMap;
}
else if (uMaterial.HasProperty(k_ColorTexture))
{
mainTexProperty = k_ColorTexture;
}
if (needsMetalRoughTexture)
{
ormImageExport = new OrmImageExport();
}
if (IsUnlit(uMaterial))
{
ExportUnlit(material, uMaterial, mainTexProperty, gltf, logger);
}
else if (isPbrMetallicRoughness)
{
success &= ExportPbrMetallicRoughness(
uMaterial,
material,
mainTexProperty,
ormImageExport,
gltf,
logger
);
}
else if (uMaterial.HasProperty(mainTexProperty))
{
var mainTex = uMaterial.GetTexture(mainTexProperty);
material.pbrMetallicRoughness = new PbrMetallicRoughness {
metallicFactor = 0,
roughnessFactor = 1.0f,
baseColor = uMaterial.HasProperty(k_BaseColor)
? uMaterial.GetColor(k_BaseColor)
: Color.white
};
if (mainTex != null)
{
material.pbrMetallicRoughness.baseColorTexture = ExportTextureInfo(mainTex, gltf);
if (material.pbrMetallicRoughness.baseColorTexture != null)
{
ExportTextureTransform(material.pbrMetallicRoughness.baseColorTexture, uMaterial, mainTexProperty, gltf);
}
}
if (uMaterial.HasProperty(k_TintColor))
{
//particles use _TintColor instead of _Color
material.pbrMetallicRoughness.baseColor = uMaterial.GetColor(k_TintColor);
}
}
if (uMaterial.HasProperty(k_OcclusionMap))
{
var occTex = uMaterial.GetTexture(k_OcclusionMap);
if (occTex != null)
{
if (occTex is Texture2D occTex2d)
{
if (ormImageExport == null)
{
material.occlusionTexture = ExportOcclusionTextureInfo(occTex2d, uMaterial, gltf);
}
else
{
material.occlusionTexture = new OcclusionTextureInfo();
ormImageExport.SetOcclusionTexture(occTex2d);
}
if (material.occlusionTexture != null)
{
ExportTextureTransform(
material.occlusionTexture,
uMaterial,
mainTexProperty, // Standard and Lit re-use main texture transform
gltf
);
}
}
else
{
logger?.Error(LogCode.TextureInvalidType, "occlusion", material.name);
success = false;
}
}
}
if (ormImageExport != null && material.pbrMetallicRoughness != null)
{
if (AddImageExport(gltf, ormImageExport, out var ormTextureId))
{
if (material.pbrMetallicRoughness.metallicRoughnessTexture != null)
{
material.pbrMetallicRoughness.metallicRoughnessTexture.index = ormTextureId;
ExportTextureTransform(material.pbrMetallicRoughness.metallicRoughnessTexture, uMaterial, k_MetallicGlossMap, gltf);
}
if (ormImageExport.hasOcclusion)
{
material.occlusionTexture.index = ormTextureId;
}
}
#if UNITY_IMAGECONVERSION
else
{
logger?.Error(LogCode.ExportImageFailed);
}
#endif
}
if (material.occlusionTexture != null)
{
if (uMaterial.HasProperty(MaterialGenerator.occlusionStrengthPropId))
{
material.occlusionTexture.strength = uMaterial.GetFloat(MaterialGenerator.occlusionStrengthPropId);
}
}
return(success);
}
bool Equals(OrmImageExport other)
{
return(m_Texture == other.m_Texture &&
m_OccTexture == other.m_OccTexture &&
m_SmoothnessTexture == other.m_SmoothnessTexture);
}
static bool ExportPbrMetallicRoughness(
UnityEngine.Material uMaterial,
Material material,
int mainTexProperty,
OrmImageExport ormImageExport,
IGltfWritable gltf,
ICodeLogger logger
)
{
var success = true;
var pbr = new PbrMetallicRoughness {
metallicFactor = 0, roughnessFactor = 1.0f
};
var hasAlphaSmoothness = uMaterial.IsKeywordEnabled(k_KeywordSmoothnessTextureAlbedoChannelA);
if (uMaterial.HasProperty(k_BaseColor))
{
pbr.baseColor = uMaterial.GetColor(k_BaseColor);
}
else
if (uMaterial.HasProperty(k_Color))
{
pbr.baseColor = uMaterial.GetColor(k_Color);
}
if (uMaterial.HasProperty(k_TintColor))
{
//particles use _TintColor instead of _Color
float white = 1;
if (uMaterial.HasProperty(k_Color))
{
var c = uMaterial.GetColor(k_Color);
white = (c.r + c.g + c.b) / 3.0f; //multiply alpha by overall whiteness of TintColor
}
pbr.baseColor = uMaterial.GetColor(k_TintColor) * white;
}
if (uMaterial.HasProperty(mainTexProperty))
{
// TODO if additive particle, render black into alpha
// TODO use private Material.GetFirstPropertyNameIdByAttribute here, supported from 2020.1+
var mainTex = uMaterial.GetTexture(mainTexProperty);
if (mainTex)
{
if (mainTex is Texture2D)
{
pbr.baseColorTexture = ExportTextureInfo(
mainTex,
gltf,
// Force RGB for the baseColor, so that the alpha (which is smoothness)
// is not used for alpha-opacity
hasAlphaSmoothness
? ImageExportBase.Format.Jpg
: ImageExportBase.Format.Unknown
);
if (pbr.baseColorTexture != null)
{
ExportTextureTransform(pbr.baseColorTexture, uMaterial, mainTexProperty, gltf);
}
}
else
{
logger?.Error(LogCode.TextureInvalidType, "main", uMaterial.name);
success = false;
}
}
}
if (uMaterial.HasProperty(k_Metallic) && !HasMetallicGlossMap(uMaterial))
{
pbr.metallicFactor = uMaterial.GetFloat(k_Metallic);
}
if (uMaterial.HasProperty(k_Glossiness) || uMaterial.HasProperty(k_Smoothness))
{
var smoothnessPropId = uMaterial.HasProperty(k_Smoothness) ? k_Smoothness : k_Glossiness;
var metallicGlossMap = uMaterial.HasProperty(k_MetallicGlossMap) ? uMaterial.GetTexture(k_MetallicGlossMap) : null;
var smoothness = uMaterial.GetFloat(smoothnessPropId);
pbr.roughnessFactor = (metallicGlossMap != null || hasAlphaSmoothness) && uMaterial.HasProperty(k_GlossMapScale)
? uMaterial.GetFloat(k_GlossMapScale)
: 1f - smoothness;
}
if (uMaterial.HasProperty(k_MetallicGlossMap))
{
var mrTex = uMaterial.GetTexture(k_MetallicGlossMap);
if (mrTex != null)
{
if (mrTex is Texture2D mrTex2d)
{
pbr.metallicRoughnessTexture = pbr.metallicRoughnessTexture ?? new TextureInfo();
ormImageExport.SetMetalGlossTexture(mrTex2d);
if (HasMetallicGlossMap(uMaterial))
{
pbr.metallicFactor = 1.0f;
}
ExportTextureTransform(pbr.metallicRoughnessTexture, uMaterial, k_MetallicGlossMap, gltf);
}
else
{
logger?.Error(LogCode.TextureInvalidType, "metallic/gloss", uMaterial.name);
success = false;
}
}
}
if (uMaterial.IsKeywordEnabled(k_KeywordSmoothnessTextureAlbedoChannelA))
{
var smoothnessTex = uMaterial.GetTexture(mainTexProperty) as Texture2D;
if (smoothnessTex != null)
{
pbr.metallicRoughnessTexture = pbr.metallicRoughnessTexture ?? new TextureInfo();
ormImageExport.SetSmoothnessTexture(smoothnessTex);
ExportTextureTransform(pbr.metallicRoughnessTexture, uMaterial, mainTexProperty, gltf);
}
}
material.pbrMetallicRoughness = pbr;
return(success);
}
