643 lines
25 KiB
C#
643 lines
25 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System;
|
|
|
|
namespace DigitalOpus.MB.Core
|
|
{
|
|
public class TextureBlenderURPLit : TextureBlender
|
|
{
|
|
static Color NeutralNormalMap = new Color(.5f, .5f, 1f);
|
|
|
|
private enum Prop
|
|
{
|
|
doColor,
|
|
doSpecular,
|
|
doMetallic,
|
|
doEmission,
|
|
doBump,
|
|
doNone,
|
|
}
|
|
|
|
private enum WorkflowMode
|
|
{
|
|
unknown,
|
|
metallic,
|
|
specular,
|
|
}
|
|
|
|
private enum SmoothnessTextureChannel
|
|
{
|
|
unknown,
|
|
albedo,
|
|
metallicSpecular,
|
|
}
|
|
|
|
// This is used to cache the non texture property values. If all non-texutre property values are the same for a property for all source textures
|
|
// then the source value will be re-used
|
|
TextureBlenderMaterialPropertyCacheHelper sourceMaterialPropertyCache = new TextureBlenderMaterialPropertyCacheHelper();
|
|
|
|
WorkflowMode m_workflowMode = WorkflowMode.unknown;
|
|
|
|
SmoothnessTextureChannel m_smoothnessTextureChannel = SmoothnessTextureChannel.unknown;
|
|
|
|
// These are cached values read in OnBeforeTintTexture and used when blending pixels.
|
|
Color m_tintColor;
|
|
|
|
bool m_doScaleAlphaCutoff;
|
|
float m_alphaCutoff;
|
|
|
|
float m_smoothness; // shared by both metallic maps and spec maps
|
|
|
|
Color m_specColor; // Used if no spec map
|
|
bool m_hasSpecGlossMap;
|
|
|
|
float m_metallic; // Used if no metallic map
|
|
bool m_hasMetallicGlossMap;
|
|
|
|
float m_bumpScale;
|
|
|
|
bool m_shaderDoesEmission;
|
|
Color m_emissionColor;
|
|
|
|
// This just makes things more efficient so we arn't doing a string comparison for each pixel.
|
|
Prop propertyToDo = Prop.doNone;
|
|
|
|
// These are the property values that will be assigned to the result material if
|
|
// generating an atlas for those properties.
|
|
Color m_generatingTintedAtlaColor = Color.white;
|
|
float m_generatingTintedAtlasMetallic = 0f;
|
|
Color m_generatingTintedAtlaSpecular = Color.black;
|
|
float m_generatingTintedAtlasMetallic_smoothness = 1f;
|
|
float m_generatingTintedAtlasSpecular_somoothness = 1f;
|
|
float m_generatingTintedAtlaBumpScale = 1f;
|
|
Color m_generatingTintedAtlaEmission = Color.white;
|
|
const float m_generatedAlphaCutoff = .5f;
|
|
|
|
// These are the default property values that will be assigned to the result materials if
|
|
// none of the source materials have a value for these properties.
|
|
Color m_notGeneratingAtlasDefaultColor = Color.white;
|
|
float m_notGeneratingAtlasDefaultMetallic = 0;
|
|
float m_notGeneratingAtlasDefaultSmoothness_MetallicWorkflow = 0f;
|
|
float m_notGeneratingAtlasDefaultSmoothness_SpecularWorkflow = 1f;
|
|
Color m_notGeneratingAtlasDefaultSpecularColor = new Color(.2f,.2f,.2f,1f);
|
|
Color m_notGeneratingAtlasDefaultEmisionColor = Color.black;
|
|
|
|
public bool DoesShaderNameMatch(string shaderName)
|
|
{
|
|
return shaderName.Equals("Universal Render Pipeline/Lit") ||
|
|
shaderName.Equals("Universal Render Pipeline/Simple Lit") ||
|
|
shaderName.Equals("Universal Render Pipeline/Baked Lit");
|
|
}
|
|
|
|
private WorkflowMode _MapFloatToWorkflowMode(float workflowMode)
|
|
{
|
|
if (workflowMode == 0f)
|
|
{
|
|
return WorkflowMode.specular;
|
|
}
|
|
else
|
|
{
|
|
return WorkflowMode.metallic;
|
|
}
|
|
}
|
|
|
|
private float _MapWorkflowModeToFloat(WorkflowMode workflowMode)
|
|
{
|
|
if (workflowMode == WorkflowMode.specular)
|
|
{
|
|
return 0f;
|
|
} else
|
|
{
|
|
return 1f;
|
|
}
|
|
}
|
|
|
|
private SmoothnessTextureChannel _MapFloatToTextureChannel(float texChannel)
|
|
{
|
|
if (texChannel == 0f)
|
|
{
|
|
return SmoothnessTextureChannel.metallicSpecular;
|
|
}
|
|
else
|
|
{
|
|
return SmoothnessTextureChannel.albedo;
|
|
}
|
|
}
|
|
|
|
private float _MapTextureChannelToFloat(SmoothnessTextureChannel workflowMode)
|
|
{
|
|
if (workflowMode == SmoothnessTextureChannel.metallicSpecular)
|
|
{
|
|
return 0f;
|
|
}
|
|
else
|
|
{
|
|
return 1f;
|
|
}
|
|
}
|
|
|
|
public void OnBeforeTintTexture(Material sourceMat, string shaderTexturePropertyName)
|
|
{
|
|
if (m_workflowMode == WorkflowMode.unknown)
|
|
{
|
|
if (sourceMat.HasProperty("_WorkflowMode"))
|
|
{
|
|
m_workflowMode = _MapFloatToWorkflowMode(sourceMat.GetFloat("_WorkflowMode"));
|
|
}
|
|
} else
|
|
{
|
|
if (sourceMat.HasProperty("_WorkflowMode") && _MapFloatToWorkflowMode(sourceMat.GetFloat("_WorkflowMode")) != m_workflowMode)
|
|
{
|
|
Debug.LogError("Using the Universal Render Pipeline TextureBlender to blend non-texture-propertyes. Some of the source materials used different 'WorkflowModes'. These "+
|
|
" cannot be blended properly. Results will be unpredictable.");
|
|
}
|
|
}
|
|
|
|
if (m_smoothnessTextureChannel == SmoothnessTextureChannel.unknown)
|
|
{
|
|
if (sourceMat.HasProperty("_SmoothnessTextureChannel"))
|
|
{
|
|
m_smoothnessTextureChannel = _MapFloatToTextureChannel(sourceMat.GetFloat("_SmoothnessTextureChannel"));
|
|
}
|
|
} else
|
|
{
|
|
if (sourceMat.HasProperty("_SmoothnessTextureChannel") && _MapFloatToTextureChannel(sourceMat.GetFloat("_SmoothnessTextureChannel")) != m_smoothnessTextureChannel)
|
|
{
|
|
Debug.LogError("Using the Universal Render Pipeline TextureBlender to blend non-texture-properties. Some of the source materials store smoothness in the Albedo texture alpha" +
|
|
" and some source materials store smoothness in the Metallic/Specular texture alpha channel. The result material can only read smoothness from one or the other. Results will be unpredictable.");
|
|
}
|
|
}
|
|
|
|
if (shaderTexturePropertyName.Equals("_BaseMap"))
|
|
{
|
|
propertyToDo = Prop.doColor;
|
|
if (sourceMat.HasProperty("_BaseColor"))
|
|
{
|
|
m_tintColor = sourceMat.GetColor("_BaseColor");
|
|
}
|
|
else
|
|
{
|
|
m_tintColor = m_generatingTintedAtlaColor;
|
|
}
|
|
|
|
if (sourceMat.HasProperty("_Surface") && // _Surface is transparent or opaque
|
|
sourceMat.HasProperty("_AlphaClip") &&
|
|
sourceMat.HasProperty("_Cutoff") &&
|
|
sourceMat.GetFloat("_Surface") == 1 && // transparent
|
|
sourceMat.GetFloat("_AlphaClip") == 1 // alpha clipping is turned on
|
|
)
|
|
{
|
|
m_doScaleAlphaCutoff = true;
|
|
m_alphaCutoff = sourceMat.GetFloat("_Cutoff");
|
|
m_alphaCutoff = Mathf.Clamp(m_alphaCutoff, .0001f, .9999f);
|
|
}
|
|
else
|
|
{
|
|
m_doScaleAlphaCutoff = false;
|
|
m_alphaCutoff = .5f;
|
|
}
|
|
}
|
|
else if (shaderTexturePropertyName.Equals("_SpecGlossMap"))
|
|
{
|
|
propertyToDo = Prop.doSpecular;
|
|
m_specColor = m_generatingTintedAtlaSpecular;
|
|
if (sourceMat.GetTexture("_SpecGlossMap") != null)
|
|
{
|
|
m_hasSpecGlossMap = true;
|
|
}
|
|
else
|
|
{
|
|
m_hasSpecGlossMap = false;
|
|
}
|
|
|
|
if (sourceMat.HasProperty("_SpecColor"))
|
|
{
|
|
m_specColor = sourceMat.GetColor("_SpecColor");
|
|
} else
|
|
{
|
|
m_specColor = new Color(0f, 0f, 0f, 1f);
|
|
}
|
|
|
|
if (sourceMat.HasProperty("_Smoothness") && m_workflowMode == WorkflowMode.specular)
|
|
{
|
|
m_smoothness = sourceMat.GetFloat("_Smoothness");
|
|
}
|
|
else if (m_workflowMode == WorkflowMode.specular)
|
|
{
|
|
m_smoothness = 1f;
|
|
}
|
|
}
|
|
else if (shaderTexturePropertyName.Equals("_MetallicGlossMap"))
|
|
{
|
|
propertyToDo = Prop.doMetallic;
|
|
if (sourceMat.GetTexture("_MetallicGlossMap") != null)
|
|
{
|
|
m_hasMetallicGlossMap = true;
|
|
}
|
|
else
|
|
{
|
|
m_hasMetallicGlossMap = false;
|
|
}
|
|
|
|
if (sourceMat.HasProperty("_Metallic"))
|
|
{
|
|
m_metallic = sourceMat.GetFloat("_Metallic");
|
|
}
|
|
else
|
|
{
|
|
m_metallic = 0f;
|
|
}
|
|
|
|
if (sourceMat.HasProperty("_Smoothness") && m_workflowMode == WorkflowMode.metallic)
|
|
{
|
|
m_smoothness = sourceMat.GetFloat("_Smoothness");
|
|
}
|
|
else if (m_workflowMode == WorkflowMode.metallic)
|
|
{
|
|
m_smoothness = 0f;
|
|
}
|
|
|
|
|
|
}
|
|
else if (shaderTexturePropertyName.Equals("_BumpMap"))
|
|
{
|
|
propertyToDo = Prop.doBump;
|
|
if (sourceMat.HasProperty(shaderTexturePropertyName))
|
|
{
|
|
if (sourceMat.HasProperty("_BumpScale"))
|
|
m_bumpScale = sourceMat.GetFloat("_BumpScale");
|
|
}
|
|
else
|
|
{
|
|
m_bumpScale = m_generatingTintedAtlaBumpScale;
|
|
}
|
|
} else if (shaderTexturePropertyName.Equals("_EmissionMap"))
|
|
{
|
|
propertyToDo = Prop.doEmission;
|
|
m_shaderDoesEmission = sourceMat.IsKeywordEnabled("_EMISSION");
|
|
if (sourceMat.HasProperty("_EmissionColor")) {
|
|
m_emissionColor = sourceMat.GetColor("_EmissionColor");
|
|
} else
|
|
{
|
|
m_generatingTintedAtlaColor = m_notGeneratingAtlasDefaultEmisionColor;
|
|
}
|
|
} else
|
|
{
|
|
propertyToDo = Prop.doNone;
|
|
}
|
|
}
|
|
|
|
public Color OnBlendTexturePixel(string propertyToDoshaderPropertyName, Color pixelColor)
|
|
{
|
|
if (propertyToDo == Prop.doColor)
|
|
{
|
|
Color c = new Color(pixelColor.r * m_tintColor.r, pixelColor.g * m_tintColor.g, pixelColor.b * m_tintColor.b, pixelColor.a * m_tintColor.a);
|
|
if (m_doScaleAlphaCutoff)
|
|
{
|
|
// The source mat is in AlphaCutoff mode. We need to blend the alpha cutoff into the alpha channel.
|
|
// The result-material will have Alpha cutoff of .5f. Scale the alpha channel pixels to account for this.
|
|
if (c.a >= m_alphaCutoff)
|
|
{
|
|
c.a = m_generatedAlphaCutoff + (1f - m_generatedAlphaCutoff) * (c.a - m_alphaCutoff) / (1f - m_alphaCutoff);
|
|
}
|
|
else
|
|
{
|
|
c.a = (m_generatedAlphaCutoff) * (c.a) / (m_alphaCutoff);
|
|
}
|
|
}
|
|
|
|
return c;
|
|
}
|
|
else if (propertyToDo == Prop.doMetallic)
|
|
{
|
|
if (m_hasMetallicGlossMap)
|
|
{
|
|
return pixelColor = new Color(pixelColor.r, pixelColor.g, pixelColor.b, pixelColor.a * m_smoothness);
|
|
}
|
|
else
|
|
{
|
|
return new Color(m_metallic, 0, 0, m_smoothness);
|
|
}
|
|
}
|
|
else if (propertyToDo == Prop.doSpecular)
|
|
{
|
|
if (m_hasSpecGlossMap)
|
|
{
|
|
return pixelColor = new Color(pixelColor.r, pixelColor.g, pixelColor.b, pixelColor.a * m_smoothness);
|
|
}
|
|
else
|
|
{
|
|
Color c = m_specColor;
|
|
c.a = m_smoothness;
|
|
return c;
|
|
}
|
|
}
|
|
else if (propertyToDo == Prop.doBump)
|
|
{
|
|
return Color.Lerp(NeutralNormalMap, pixelColor, m_bumpScale);
|
|
}
|
|
else if (propertyToDo == Prop.doEmission)
|
|
{
|
|
if (m_shaderDoesEmission)
|
|
{
|
|
return new Color(pixelColor.r * m_emissionColor.r, pixelColor.g * m_emissionColor.g, pixelColor.b * m_emissionColor.b, pixelColor.a * m_emissionColor.a);
|
|
}
|
|
else
|
|
{
|
|
return Color.black;
|
|
}
|
|
}
|
|
return pixelColor;
|
|
}
|
|
|
|
public bool NonTexturePropertiesAreEqual(Material a, Material b)
|
|
{
|
|
if (!TextureBlenderFallback._compareColor(a, b, m_generatingTintedAtlaColor, "_BaseColor"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!TextureBlenderFallback._compareColor(a, b, m_generatingTintedAtlaSpecular, "_SpecColor"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (a.HasProperty("_Surface") && b.HasProperty("_Surface") &&
|
|
a.GetFloat("_AlphaClip") == 1 && b.GetFloat("_AlphaClip") == 1 &&
|
|
a.HasProperty("_Cutoff") && b.HasProperty("_Cutoff"))
|
|
{
|
|
// Compare alpha cutoff values
|
|
if (a.HasProperty("_Cutoff") != b.HasProperty("_Cutoff"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (m_workflowMode == WorkflowMode.specular){
|
|
bool aHasSpecTex = a.HasProperty("_SpecGlossMap") && a.GetTexture("_SpecGlossMap") != null;
|
|
bool bHasSpecTex = b.HasProperty("_SpecGlossMap") && b.GetTexture("_SpecGlossMap") != null;
|
|
|
|
if (aHasSpecTex && bHasSpecTex)
|
|
{
|
|
if (!TextureBlenderFallback._compareFloat(a, b, m_notGeneratingAtlasDefaultSmoothness_SpecularWorkflow, "_Smoothness"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (!aHasSpecTex && !bHasSpecTex)
|
|
{
|
|
if (!TextureBlenderFallback._compareColor(a, b, m_notGeneratingAtlasDefaultSpecularColor, "_SpecColor") &&
|
|
!TextureBlenderFallback._compareFloat(a, b, m_notGeneratingAtlasDefaultSmoothness_SpecularWorkflow, "_Smoothness"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (m_workflowMode == WorkflowMode.metallic) {
|
|
bool aHasMetallicTex = a.HasProperty("_MetallicGlossMap") && a.GetTexture("_MetallicGlossMap") != null;
|
|
bool bHasMetallicTex = b.HasProperty("_MetallicGlossMap") && b.GetTexture("_MetallicGlossMap") != null;
|
|
if (aHasMetallicTex && bHasMetallicTex)
|
|
{
|
|
if (!TextureBlenderFallback._compareFloat(a, b, m_notGeneratingAtlasDefaultSmoothness_MetallicWorkflow, "_Smoothness"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (!aHasMetallicTex && !bHasMetallicTex)
|
|
{
|
|
if (!TextureBlenderFallback._compareFloat(a, b, m_notGeneratingAtlasDefaultMetallic, "_Metallic") &&
|
|
!TextureBlenderFallback._compareFloat(a, b, m_notGeneratingAtlasDefaultSmoothness_MetallicWorkflow, "_Smoothness"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!TextureBlenderFallback._compareFloat(a, b, m_generatingTintedAtlaBumpScale, "_BumpScale"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (a.IsKeywordEnabled("_EMISSION") != b.IsKeywordEnabled("_EMISSION"))
|
|
{
|
|
return false;
|
|
}
|
|
if (a.IsKeywordEnabled("_EMISSION"))
|
|
{
|
|
if (!TextureBlenderFallback._compareColor(a, b, m_generatingTintedAtlaEmission, "_EmissionColor"))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void SetNonTexturePropertyValuesOnResultMaterial(Material resultMaterial)
|
|
{
|
|
if (m_workflowMode != WorkflowMode.unknown)
|
|
{
|
|
resultMaterial.SetFloat("_WorkflowMode", _MapWorkflowModeToFloat(m_workflowMode));
|
|
}
|
|
|
|
if (m_smoothnessTextureChannel != SmoothnessTextureChannel.unknown)
|
|
{
|
|
resultMaterial.SetFloat("_SmoothnessTextureChannel", _MapTextureChannelToFloat(m_smoothnessTextureChannel));
|
|
}
|
|
|
|
if (resultMaterial.GetTexture("_BaseMap") != null)
|
|
{
|
|
resultMaterial.SetColor("_BaseColor", m_generatingTintedAtlaColor);
|
|
if (resultMaterial.GetFloat("_Surface") == 1 && // transparent
|
|
resultMaterial.GetFloat("_AlphaClip") == 1 && // alpha clipping mode.
|
|
resultMaterial.HasProperty("_Cutoff")) // Alpha cutoff
|
|
{
|
|
resultMaterial.SetFloat("_Cutoff", m_generatedAlphaCutoff);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
resultMaterial.SetColor("_BaseColor", (Color)sourceMaterialPropertyCache.GetValueIfAllSourceAreTheSameOrDefault("_BaseColor", m_notGeneratingAtlasDefaultColor));
|
|
}
|
|
|
|
if (m_workflowMode == WorkflowMode.specular)
|
|
{
|
|
if (resultMaterial.GetTexture("_SpecGlossMap") != null)
|
|
{
|
|
resultMaterial.SetColor("_SpecColor", m_generatingTintedAtlaSpecular);
|
|
resultMaterial.SetFloat("_Smoothness", m_generatingTintedAtlasSpecular_somoothness);
|
|
}
|
|
else
|
|
{
|
|
resultMaterial.SetColor("_SpecColor", (Color)sourceMaterialPropertyCache.GetValueIfAllSourceAreTheSameOrDefault("_SpecColor", m_notGeneratingAtlasDefaultSpecularColor));
|
|
resultMaterial.SetFloat("_Smoothness", m_smoothness);
|
|
}
|
|
}
|
|
|
|
if (m_workflowMode == WorkflowMode.metallic)
|
|
{
|
|
if (resultMaterial.GetTexture("_MetallicGlossMap") != null)
|
|
{
|
|
resultMaterial.SetFloat("_Metallic", m_generatingTintedAtlasMetallic);
|
|
resultMaterial.SetFloat("_Smoothness", m_generatingTintedAtlasMetallic_smoothness);
|
|
}
|
|
else
|
|
{
|
|
resultMaterial.SetFloat("_Metallic", (float)sourceMaterialPropertyCache.GetValueIfAllSourceAreTheSameOrDefault("_Metallic", m_notGeneratingAtlasDefaultMetallic));
|
|
resultMaterial.SetFloat("_Smoothness", m_smoothness);
|
|
}
|
|
}
|
|
|
|
if (resultMaterial.GetTexture("_BumpMap") != null)
|
|
{
|
|
resultMaterial.SetFloat("_BumpScale", m_generatingTintedAtlaBumpScale);
|
|
}
|
|
else
|
|
{
|
|
resultMaterial.SetFloat("_BumpScale", m_generatingTintedAtlaBumpScale);
|
|
}
|
|
|
|
if (resultMaterial.GetTexture("_EmissionMap") != null)
|
|
{
|
|
resultMaterial.EnableKeyword("_EMISSION");
|
|
resultMaterial.SetColor("_EmissionColor", Color.white);
|
|
}
|
|
else
|
|
{
|
|
resultMaterial.DisableKeyword("_EMISSION");
|
|
resultMaterial.SetColor("_EmissionColor", (Color)sourceMaterialPropertyCache.GetValueIfAllSourceAreTheSameOrDefault("_EmissionColor", m_notGeneratingAtlasDefaultEmisionColor));
|
|
}
|
|
}
|
|
|
|
|
|
public Color GetColorIfNoTexture(Material mat, ShaderTextureProperty texPropertyName)
|
|
{
|
|
if (texPropertyName.name.Equals("_BumpMap"))
|
|
{
|
|
return new Color(.5f, .5f, 1f);
|
|
}
|
|
else if (texPropertyName.name.Equals("_BaseMap"))
|
|
{
|
|
/*
|
|
if (mat != null && mat.HasProperty("_BaseColor"))
|
|
{
|
|
try
|
|
{ //need try because can't garantee _Color is a color
|
|
Color c = mat.GetColor("_BaseColor");
|
|
sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_BaseColor", c);
|
|
}
|
|
catch (Exception) { }
|
|
return Color.white;
|
|
}
|
|
*/
|
|
// Why don't we return _BaseColor here?
|
|
// Source object has: no-texture, _BaseColor ==> look like _BaseColor
|
|
// Atlas needs:
|
|
// CORRECT: whiteBlock, _BaseColor ==> look like _BaseColor
|
|
// WRONG: solidTex_Color, _BaseColor ==> look like _Color * _BaseColor
|
|
return Color.white;
|
|
}
|
|
else if (texPropertyName.name.Equals("_SpecGlossMap"))
|
|
{
|
|
if (mat != null && mat.HasProperty("_SpecColor"))
|
|
{
|
|
try
|
|
{ //need try because can't garantee _Color is a color
|
|
Color c = mat.GetColor("_SpecColor");
|
|
/*
|
|
if (mat.HasProperty("_Glossiness"))
|
|
{
|
|
try
|
|
{
|
|
c.a = mat.GetFloat("_Glossiness");
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
*/
|
|
sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_SpecColor", c);
|
|
//sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_Glossiness", c.a);
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
return new Color(0f, 0f, 0f, .5f);
|
|
}
|
|
else if (texPropertyName.name.Equals("_MetallicGlossMap"))
|
|
{
|
|
if (mat != null && mat.HasProperty("_Metallic"))
|
|
{
|
|
try
|
|
{ //need try because can't garantee _Metallic is a float
|
|
float v = mat.GetFloat("_Metallic");
|
|
Color c = new Color(v, v, v);
|
|
|
|
if (mat.HasProperty("_Smoothness"))
|
|
{
|
|
try
|
|
{
|
|
c.a = mat.GetFloat("_Smoothness");
|
|
}
|
|
|
|
catch (Exception) { }
|
|
}
|
|
|
|
sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_Metallic", v);
|
|
sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_Smoothness", c.a);
|
|
}
|
|
catch (Exception) { }
|
|
return new Color(0f, 0f, 0f, .5f);
|
|
}
|
|
else
|
|
{
|
|
return new Color(0f, 0f, 0f, .5f);
|
|
}
|
|
}
|
|
else if (texPropertyName.name.Equals("_OcclusionMap"))
|
|
{
|
|
return new Color(1f, 1f, 1f, 1f);
|
|
}
|
|
else if (texPropertyName.name.Equals("_EmissionMap"))
|
|
{
|
|
if (mat != null)
|
|
{
|
|
if (mat.IsKeywordEnabled("_EMISSION"))
|
|
{
|
|
if (mat.HasProperty("_EmissionColor"))
|
|
{
|
|
try
|
|
{
|
|
Color c = mat.GetColor("_EmissionColor");
|
|
sourceMaterialPropertyCache.CacheMaterialProperty(mat, "_EmissionColor", c);
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
else
|
|
{
|
|
return Color.black;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Color.black;
|
|
}
|
|
}
|
|
}
|
|
else if (texPropertyName.name.Equals("_DetailMask"))
|
|
{
|
|
return new Color(0f, 0f, 0f, 0f);
|
|
}
|
|
return new Color(1f, 1f, 1f, 0f);
|
|
}
|
|
|
|
}
|
|
}
|