private void TransformSpecularGlossiness(SpecularGlossinessShaderArguments arguments, string baseColorName)
{
var sourceFileTimestampUtc = ExportUtils.GetLastWriteTimeUtc(arguments.Diffuse,
arguments.PBRSpecular.Texture, arguments.Smoothness.Texture);
var assetGuid =
(arguments.Diffuse ?? arguments.PBRSpecular.Texture ?? arguments.Smoothness.Texture).GetKey();
if (_engine.IsUpToDate(assetGuid, baseColorName, sourceFileTimestampUtc))
{
return;
}
var tmpMaterial =
new Material(
Shader.Find("Hidden/UnityToCustomEngineExporter/Urho3D/ConvertSpecularToMetallicRoughness"));
Texture mainTexture = null;
Texture specularTexture = null;
Texture smoothnessTexture = null;
try
{
mainTexture = EnsureTexture(new TextureOrColor(arguments.Diffuse, arguments.DiffuseColor));
specularTexture = EnsureTexture(arguments.PBRSpecular);
smoothnessTexture = EnsureTexture(arguments.Smoothness);
var(width, height) = MaxTexutreSize(mainTexture, specularTexture, smoothnessTexture);
tmpMaterial.SetTexture("_MainTex", mainTexture);
tmpMaterial.SetTexture("_SpecGlossMap", specularTexture);
tmpMaterial.SetFloat("_SmoothnessScale",
arguments.GlossinessTextureScale *
(arguments.Smoothness.Texture != null ? 1.0f : arguments.Glossiness));
tmpMaterial.SetTexture("_Smoothness", smoothnessTexture);
new TextureProcessor().ProcessAndSaveTexture(mainTexture, width, height, tmpMaterial,
_engine.GetTargetFilePath(baseColorName));
WriteOptions(assetGuid, baseColorName, sourceFileTimestampUtc,
(ExportUtils.GetTextureOptions(mainTexture) ?? ExportUtils.GetTextureOptions(specularTexture) ??
ExportUtils.GetTextureOptions(smoothnessTexture)).WithSRGB(false));
}
finally
{
Object.DestroyImmediate(tmpMaterial);
DestroyTmpTexture(arguments.Diffuse, mainTexture);
DestroyTmpTexture(arguments.PBRSpecular, specularTexture);
DestroyTmpTexture(arguments.Smoothness, smoothnessTexture);
}
}
public void ExportPBRTextures(SpecularGlossinessShaderArguments arguments, UrhoPBRMaterial urhoMaterial)
{
if (!_engine.Options.ExportTextures)
{
return;
}
if (!string.IsNullOrWhiteSpace(urhoMaterial.MetallicRoughnessTexture))
{
TransformSpecularGlossiness(arguments, urhoMaterial.MetallicRoughnessTexture);
}
if (!string.IsNullOrWhiteSpace(urhoMaterial.BaseColorTexture))
{
TransformDiffuse(arguments, urhoMaterial.BaseColorTexture);
}
if (!string.IsNullOrWhiteSpace(urhoMaterial.AOTexture))
{
TransformAOTexture(arguments, urhoMaterial.AOTexture);
}
if (!string.IsNullOrWhiteSpace(urhoMaterial.NormalTexture))
{
TransformNormal(arguments.Bump, arguments.BumpScale, urhoMaterial.NormalTexture);
}
}
public void SchedulePBRTextures(SpecularGlossinessShaderArguments arguments, UrhoPBRMaterial urhoMaterial)
{
EditorTaskScheduler.Default.ScheduleForegroundTask(
() => _textureExporter.ExportPBRTextures(arguments, urhoMaterial),
urhoMaterial.MetallicRoughnessTexture);
}
private SpecularGlossinessShaderArguments SetupSpecularGlossinessPBR(Material material)
{
var arguments = new SpecularGlossinessShaderArguments();
SetupFlags(material, arguments);
var shader = material.shader;
for (var i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
{
var propertyName = ShaderUtil.GetPropertyName(shader, i);
var propertyType = ShaderUtil.GetPropertyType(shader, i);
switch (propertyType)
{
case ShaderUtil.ShaderPropertyType.Color:
{
var color = material.GetColor(propertyName);
switch (propertyName)
{
case "_Color":
arguments.DiffuseColor = color;
break;
case "_EmissionColor":
arguments.EmissiveColor = color;
break;
case "_SpecColor":
arguments.PBRSpecular = new TextureOrColor(arguments.PBRSpecular.Texture, color);
break;
}
break;
}
case ShaderUtil.ShaderPropertyType.Float:
{
var value = material.GetFloat(propertyName);
switch (propertyName)
{
case "_BumpScale":
arguments.BumpScale = value;
break;
case "_DetailNormalMapScale": break;
case "_DstBlend": break;
case "_GlossyReflections": break;
case "_Mode": break;
case "_SmoothnessTextureChannel":
arguments.SmoothnessTextureChannel = (SmoothnessTextureChannel)value;
break;
case "_SpecularHighlights": break;
case "_SrcBlend": break;
case "_UVSec": break;
case "_ZWrite": break;
}
break;
}
case ShaderUtil.ShaderPropertyType.Range:
{
var value = material.GetFloat(propertyName);
switch (propertyName)
{
case "_Cutoff":
arguments.Cutoff = value;
break;
case "_GlossMapScale":
arguments.GlossinessTextureScale = value;
break;
case "_Glossiness":
arguments.Glossiness = value;
break;
case "_OcclusionStrength":
arguments.OcclusionStrength = value;
break;
case "_Parallax": break;
}
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv:
{
var texture = material.GetTexture(propertyName);
switch (propertyName)
{
case "_BumpMap":
arguments.Bump = texture;
break;
case "_DetailAlbedoMap":
arguments.DetailDiffuse = texture;
break;
case "_DetailMask":
arguments.Detail = texture;
break;
case "_DetailNormalMap":
arguments.DetailNormal = texture;
break;
case "_EmissionMap":
arguments.Emission = texture;
break;
case "_MainTex":
arguments.Diffuse = texture;
break;
case "_OcclusionMap":
arguments.Occlusion = texture;
break;
case "_ParallaxMap":
arguments.Parallax = texture;
break;
case "_SpecGlossMap":
arguments.PBRSpecular = new TextureOrColor(texture, arguments.PBRSpecular.Color);
break;
}
break;
}
}
}
return(arguments);
}
public UrhoPBRMaterial FromSpecularGlossiness(SpecularGlossinessShaderArguments arguments)
{
var material = new UrhoPBRMaterial();
material.NormalTexture = GetScaledNormalTextureName(arguments.Bump, arguments.BumpScale);
material.EmissiveTexture = Engine.EvaluateTextrueName(arguments.Emission);
material.AOTexture = BuildAOTextureName(arguments.Occlusion, arguments.OcclusionStrength);
var diffuseTextrueName = Engine.EvaluateTextrueName(arguments.Diffuse);
var specularTexture = Engine.EvaluateTextrueName(arguments.PBRSpecular.Texture);
string smoothnessTexture;
if (arguments.Smoothness.Texture == arguments.Diffuse)
{
smoothnessTexture = diffuseTextrueName;
}
else
{
smoothnessTexture = specularTexture;
}
if (string.IsNullOrWhiteSpace(specularTexture) && string.IsNullOrWhiteSpace(diffuseTextrueName))
{
var pbrValues = PBRUtils.ConvertToMetallicRoughnessSRGB(new PBRUtils.SpecularGlossiness
{
diffuse = arguments.DiffuseColor,
specular = arguments.PBRSpecular.Color,
opacity = arguments.DiffuseColor.a,
glossiness = arguments.Glossiness
}).linear();
material.BaseColor = pbrValues.baseColor;
material.Metallic = pbrValues.metallic;
material.Roughness = pbrValues.roughness;
}
else
{
{
var baseColorTextureNameBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(diffuseTextrueName))
{
baseColorTextureNameBuilder.Append(
Path.GetDirectoryName(diffuseTextrueName).FixAssetSeparator());
}
else
{
baseColorTextureNameBuilder.Append(Path.GetDirectoryName(specularTexture).FixAssetSeparator());
}
if (baseColorTextureNameBuilder.Length > 0)
{
baseColorTextureNameBuilder.Append('/');
}
if (!string.IsNullOrWhiteSpace(diffuseTextrueName))
{
baseColorTextureNameBuilder.Append(Path.GetFileNameWithoutExtension(diffuseTextrueName));
}
else
{
baseColorTextureNameBuilder.Append(FormatRGB(arguments.DiffuseColor.linear));
}
baseColorTextureNameBuilder.Append('.');
if (!string.IsNullOrWhiteSpace(specularTexture))
{
baseColorTextureNameBuilder.Append(Path.GetFileNameWithoutExtension(specularTexture));
}
else
{
baseColorTextureNameBuilder.Append(FormatRGB(arguments.PBRSpecular.Color.linear));
}
baseColorTextureNameBuilder.Append(".BaseColor.dds");
material.BaseColorTexture = baseColorTextureNameBuilder.ToString();
}
{
var metallicTextureNameBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(specularTexture))
{
metallicTextureNameBuilder.Append(Path.GetDirectoryName(specularTexture).FixAssetSeparator());
}
else
{
metallicTextureNameBuilder.Append(Path.GetDirectoryName(diffuseTextrueName)
.FixAssetSeparator());
}
if (metallicTextureNameBuilder.Length > 0)
{
metallicTextureNameBuilder.Append('/');
}
if (!string.IsNullOrWhiteSpace(specularTexture))
{
metallicTextureNameBuilder.Append(Path.GetFileNameWithoutExtension(specularTexture));
}
else
{
metallicTextureNameBuilder.Append(FormatRGB(arguments.PBRSpecular.Color.linear));
}
metallicTextureNameBuilder.Append('.');
if (!string.IsNullOrWhiteSpace(diffuseTextrueName))
{
metallicTextureNameBuilder.Append(Path.GetFileNameWithoutExtension(diffuseTextrueName));
}
else
{
metallicTextureNameBuilder.Append(FormatRGB(arguments.DiffuseColor.linear));
}
if (!string.IsNullOrWhiteSpace(smoothnessTexture))
{
if (arguments.GlossinessTextureScale < 0.999f)
{
metallicTextureNameBuilder.Append('.');
metallicTextureNameBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0:0.000}",
arguments.GlossinessTextureScale);
}
}
else
{
if (arguments.Glossiness > 0)
{
metallicTextureNameBuilder.Append('.');
metallicTextureNameBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0:0.000}",
arguments.Glossiness);
}
}
metallicTextureNameBuilder.Append(".MetallicRoughness.dds");
material.MetallicRoughnessTexture = metallicTextureNameBuilder.ToString();
}
if (arguments.Diffuse != null)
{
material.BaseColor = arguments.DiffuseColor.linear;
}
else
{
material.BaseColor = Color.white;
}
}
material.AlphaBlend = arguments.Transparent;
if (arguments.AlphaTest)
{
material.PixelShaderDefines.Add("ALPHAMASK");
}
if (arguments.Emission != null)
{
material.EmissiveColor = Color.white;
}
else
{
material.EmissiveColor = arguments.EmissiveColor.linear;
}
material.MatSpecColor = new Color(1, 1, 1, 0);
material.UOffset = new Vector4(arguments.MainTextureScale.x, 0, 0, arguments.MainTextureOffset.x);
material.VOffset = new Vector4(0, arguments.MainTextureScale.y, 0, arguments.MainTextureOffset.y);
material.EvaluateTechnique();
return(material);
}
private void ExportSpecularGlossiness(AssetContext asset, SpecularGlossinessShaderArguments arguments)
{
using (var writer = asset.DestinationFolder.CreateXml(asset.UrhoAssetName))
{
if (writer == null)
{
return;
}
writer.WriteStartDocument();
writer.WriteWhitespace(Environment.NewLine);
writer.WriteStartElement("material");
writer.WriteWhitespace(Environment.NewLine);
if (arguments.Diffuse != null)
{
// Albedo
if (arguments.PBRSpecular != null)
{
// Albedo, MetallicGloss
if (arguments.Bump != null)
{
// Albedo, MetallicGloss, Normal
if (arguments.Emission)
{
// Albedo, MetallicGloss, Normal, Emission
if (arguments.Transparent)
{
WriteTechnique(writer,
"Techniques/PBR/PBRMetallicRoughDiffNormalSpecEmissiveAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRMetallicRoughDiffNormalSpecEmissive.xml");
}
WriteTexture(arguments.Emission, writer, "emissive");
}
else
{
// Albedo, MetallicGloss, Normal, No Emission
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRMetallicRoughDiffNormalSpecAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRMetallicRoughDiffNormalSpec.xml");
}
}
WriteTexture(arguments.Bump, writer, "normal");
}
else
{
// Albedo, MetallicGloss, No Normal
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRMetallicRoughDiffSpecAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRMetallicRoughDiffSpec.xml");
}
}
if (_assets.TryGetTexturePath(arguments.PBRSpecular, out var baseAssetName))
{
var textureReferences = new TextureReferences(TextureSemantic.PBRSpecularGlossiness, 1.0f,
arguments.SmoothnessTextureChannel == SmoothnessTextureChannel.AlbedoAlpha
? arguments.Diffuse
: arguments.PBRSpecular, arguments.SmoothnessTextureChannel);
var textureOutputName =
TextureExporter.GetTextureOutputName(baseAssetName, textureReferences);
WriteTexture(textureOutputName, writer, "specular");
}
}
else
{
// Albedo, No MetallicGloss
if (arguments.Bump != null)
{
// Albedo, No MetallicGloss, Normal
if (arguments.Emission != null)
{
// Albedo, No MetallicGloss, Normal, Emission
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRDiffNormalEmissiveAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRDiffNormalEmissive.xml");
}
WriteTexture(arguments.Emission, writer, "emissive");
}
else
{
// Albedo, No MetallicGloss, Normal, No Emission
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRDiffNormalAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRDiffNormal.xml");
}
}
WriteTexture(arguments.Bump, writer, "normal");
}
else
{
// Albedo, No MetallicGloss, No Normal
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRDiffAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRDiff.xml");
}
}
}
if (_assets.TryGetTexturePath(arguments.Diffuse, out var diffuseName))
{
var textureReferences = new TextureReferences(TextureSemantic.PBRDiffuse, 1.0f,
arguments.PBRSpecular, arguments.SmoothnessTextureChannel);
var textureOutputName = TextureExporter.GetTextureOutputName(diffuseName, textureReferences);
WriteTexture(textureOutputName, writer, "diffuse");
}
}
else
{
// No albedo
if (arguments.Transparent)
{
WriteTechnique(writer, "Techniques/PBR/PBRNoTextureAlpha.xml");
}
else
{
WriteTechnique(writer, "Techniques/PBR/PBRNoTexture.xml");
}
}
WriteParameter(writer, "MatDiffColor", BaseNodeExporter.Format(arguments.DiffuseColor));
if (arguments.HasEmission)
{
WriteParameter(writer, "MatEmissiveColor", BaseNodeExporter.FormatRGB(arguments.EmissiveColor));
}
WriteParameter(writer, "MatEnvMapColor", BaseNodeExporter.FormatRGB(Color.white));
WriteParameter(writer, "MatSpecColor", BaseNodeExporter.Format(Vector4.zero));
if (arguments.PBRSpecular != null)
{
WriteParameter(writer, "Roughness", BaseNodeExporter.Format(0));
WriteParameter(writer, "Metallic", BaseNodeExporter.Format(0));
}
else
{
////TODO: Evaluate correct parameters:
WriteParameter(writer, "Roughness", BaseNodeExporter.Format(0.0f));
WriteParameter(writer, "Metallic", BaseNodeExporter.Format(0.0f));
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
