public static void HDSpeedTree8MaterialFinalizer(Material mat)
{
SetHDSpeedTree8Defaults(mat);
// Need to call this again after reconfiguring keyword toggles
HDShaderUtils.ResetMaterialKeywords(mat);
}
/// <summary>
/// Renders the properties in the block.
/// </summary>
protected override void OnGUIOpen()
{
// Filter out properties we don't want to draw:
if ((m_Features & Features.ExposedProperties) != 0)
{
PropertiesDefaultGUI(properties);
}
// If we change a property in a shadergraph, we trigger a material keyword reset
if (CheckPropertyChanged(properties))
{
foreach (var material in materials)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
}
if ((m_Features & Features.DiffusionProfileAsset) != 0)
{
DrawDiffusionProfileUI();
}
if ((m_Features & Features.ShadowMatte) != 0 && materials.All(m => m.HasProperty(kShadowMatteFilter)))
{
DrawShadowMatteToggle();
}
}
static void MetallicRemapping(Material material, HDShaderUtils.ShaderID id)
{
const string kMetallicRemapMax = "_MetallicRemapMax";
// Lit shaders now have metallic remapping for the mask map
if (id == HDShaderUtils.ShaderID.Lit || id == HDShaderUtils.ShaderID.LitTesselation ||
id == HDShaderUtils.ShaderID.LayeredLit || id == HDShaderUtils.ShaderID.LayeredLitTesselation)
{
const string kMetallic = "_Metallic";
if (material.HasProperty(kMetallic) && material.HasProperty(kMetallicRemapMax))
{
var metallic = material.GetFloat(kMetallic);
material.SetFloat(kMetallicRemapMax, metallic);
}
}
else if (id == HDShaderUtils.ShaderID.Decal)
{
HDShaderUtils.ResetMaterialKeywords(material);
var serializedMaterial = new SerializedObject(material);
const string kMetallicScale = "_MetallicScale";
float metallicScale = 1.0f;
if (TryFindProperty(serializedMaterial, kMetallicScale, SerializedType.Float, out var propertyMetallicScale, out _, out _))
{
metallicScale = propertyMetallicScale.floatValue;
RemoveSerializedFloat(serializedMaterial, kMetallicScale);
}
serializedMaterial.ApplyModifiedProperties();
material.SetFloat(kMetallicRemapMax, metallicScale);
}
}
// Not used currently:
// TODO: Script like this must also work with embed material in scene (i.e we need to catch
// .unity scene and load material and patch in memory. And it must work with perforce
// i.e automatically checkout all those files).
static void SpecularOcclusionMode(Material material, HDShaderUtils.ShaderID id)
{
switch (id)
{
case HDShaderUtils.ShaderID.Lit:
case HDShaderUtils.ShaderID.LayeredLit:
case HDShaderUtils.ShaderID.LitTesselation:
case HDShaderUtils.ShaderID.LayeredLitTesselation:
var serializedObject = new SerializedObject(material);
var specOcclusionMode = 1;
if (FindProperty(serializedObject, "_EnableSpecularOcclusion", SerializedType.Boolean).property != null)
{
var enableSpecOcclusion = GetSerializedBoolean(serializedObject, "_EnableSpecularOcclusion");
if (enableSpecOcclusion)
{
specOcclusionMode = 2;
}
RemoveSerializedBoolean(serializedObject, "_EnableSpecularOcclusion");
serializedObject.ApplyModifiedProperties();
}
material.SetInt("_SpecularOcclusionMode", specOcclusionMode);
HDShaderUtils.ResetMaterialKeywords(material);
break;
}
}
// This upgrade functioncopy all the keywords needed for the BlendStates
// to be synced with their master node values, then it calls the HDRP material keyword reset function and finally
// it set the render queue of the material to match the one on the shader graph.
// It's required to sync the shader default properties with the material because when you create a new material,
// by default the Lit shader is assigned to it and so write all his properties into the material. It's a problem
// because now that the shader graphs uses these properties, the material properties don't match the shader settings.
// This function basically fix this.
static bool UpdateMaterial_ShaderGraphRenderStates(string path, Material mat)
{
// We only need to upgrade shadergraphs materials
if (GraphUtil.IsShaderGraph(mat.shader))
{
var defaultProperties = new Material(mat.shader);
foreach (var floatToReset in floatPropertiesToReset)
{
if (mat.HasProperty(floatToReset))
{
mat.SetFloat(floatToReset, defaultProperties.GetFloat(floatToReset));
}
}
foreach (var vectorToReset in vectorPropertiesToReset)
{
if (mat.HasProperty(vectorToReset))
{
mat.SetVector(vectorToReset, defaultProperties.GetVector(vectorToReset));
}
}
HDShaderUtils.ResetMaterialKeywords(mat);
mat.renderQueue = mat.shader.renderQueue;
defaultProperties = null;
return(true);
}
return(false);
}
static bool ResetAllLoadedMaterialKeywords(string descriptionPrefix, float progressScale, float progressOffset)
{
var materials = Resources.FindObjectsOfTypeAll <Material>();
bool VCSEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
bool anyMaterialDirty = false; // Will be true if any material is dirty.
for (int i = 0, length = materials.Length; i < length; i++)
{
EditorUtility.DisplayProgressBar(
"Setup materials Keywords...",
string.Format("{0}{1} / {2} materials cleaned.", descriptionPrefix, i, length),
(i / (float)(length - 1)) * progressScale + progressOffset);
CoreEditorUtils.CheckOutFile(VCSEnabled, materials[i]);
if (HDShaderUtils.ResetMaterialKeywords(materials[i]))
{
anyMaterialDirty = true;
}
}
return(anyMaterialDirty);
}
static void OnShaderGraphSaved(Shader shader)
{
// Iterate all Materials
string[] materialGuids = AssetDatabase.FindAssets(kMaterialFilter);
try
{
for (int i = 0, length = materialGuids.Length; i < length; i++)
{
// Only update progress bar every 10 materials
if (i % 10 == 9)
{
EditorUtility.DisplayProgressBar(
"Updating dependent materials...",
string.Format("{0} / {1} materials updated.", i, length),
i / (float)(length - 1));
}
// Get Material object
string materialPath = AssetDatabase.GUIDToAssetPath(materialGuids[i]);
Material material = AssetDatabase.LoadAssetAtPath <Material>(materialPath);
// Reset keywords
if (material.shader.name == shader.name)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
}
}
finally
{
EditorUtility.ClearProgressBar();
}
}
static void MoreMaterialSurfaceOptionFromShaderGraph(Material material, HDShaderUtils.ShaderID id)
{
if (material.shader.IsShaderGraph())
{
// Synchronize properties we exposed from SG to the material
ResetFloatProperty(kReceivesSSR);
ResetFloatProperty(kReceivesSSRTransparent);
ResetFloatProperty(kEnableDecals);
ResetFloatProperty(kEnableBlendModePreserveSpecularLighting);
ResetFloatProperty(kTransparentWritingMotionVec);
ResetFloatProperty(kAddPrecomputedVelocity);
ResetFloatProperty(kDepthOffsetEnable);
}
void ResetFloatProperty(string propName)
{
int propIndex = material.shader.FindPropertyIndex(propName);
if (propIndex == -1)
{
return;
}
float defaultValue = material.shader.GetPropertyDefaultFloatValue(propIndex);
material.SetFloat(propName, defaultValue);
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void MigrateDecalRenderQueue(Material material, HDShaderUtils.ShaderID id)
{
const string kSupportDecals = "_SupportDecals";
// Take the opportunity to remove _SupportDecals from Unlit as it is not suppose to be here
if (HDShaderUtils.IsUnlitHDRPShader(material.shader))
{
var serializedMaterial = new SerializedObject(material);
if (TryFindProperty(serializedMaterial, kSupportDecals, SerializedType.Integer, out var property, out _, out _))
{
RemoveSerializedInt(serializedMaterial, kSupportDecals);
serializedMaterial.ApplyModifiedProperties();
}
}
if (material.HasProperty(kSupportDecals))
{
bool supportDecal = material.GetFloat(kSupportDecals) > 0.0f;
if (supportDecal)
{
// Update material render queue to be in Decal render queue based on the value of decal property (see HDRenderQueue.cs)
if (material.renderQueue == ((int)UnityEngine.Rendering.RenderQueue.Geometry))
{
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Geometry + 225;
}
else if (material.renderQueue == ((int)UnityEngine.Rendering.RenderQueue.AlphaTest))
{
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest + 25;
}
}
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void AlphaToMaskUIFix(Material material, HDShaderUtils.ShaderID id)
{
if (material.HasProperty(kAlphaToMask) && material.HasProperty(kAlphaToMaskInspector))
{
material.SetFloat(kAlphaToMaskInspector, material.GetFloat(kAlphaToMask));
HDShaderUtils.ResetMaterialKeywords(material);
}
}
public override void Convert(Material srcMaterial, Material dstMaterial)
{
//dstMaterial.hideFlags = HideFlags.DontUnloadUnusedAsset;
base.Convert(srcMaterial, dstMaterial);
HDShaderUtils.ResetMaterialKeywords(dstMaterial);
}
void OnPostprocessMaterial(Material material)
{
if (!HDShaderUtils.IsHDRPShader(material.shader, upgradable: true))
{
return;
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void ForceForwardEmissiveForDeferred(Material material, HDShaderUtils.ShaderID id)
{
// Force Forward emissive for deferred pass is only setup for Lit shader
if (id == HDShaderUtils.ShaderID.SG_Lit || id == HDShaderUtils.ShaderID.Lit || id == HDShaderUtils.ShaderID.LitTesselation ||
id == HDShaderUtils.ShaderID.LayeredLit || id == HDShaderUtils.ShaderID.LayeredLitTesselation)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
}
//example migration method, remove it after first real migration
//static void EmissiveIntensityToColor(Material material, ShaderID id)
//{
// switch(id)
// {
// case ShaderID.Lit:
// case ShaderID.LitTesselation:
// var emissiveIntensity = material.GetFloat("_EmissiveIntensity");
// var emissiveColor = Color.black;
// if (material.HasProperty("_EmissiveColor"))
// emissiveColor = material.GetColor("_EmissiveColor");
// emissiveColor *= emissiveIntensity;
// emissiveColor.a = 1.0f;
// material.SetColor("_EmissiveColor", emissiveColor);
// material.SetColor("_EmissionColor", Color.white);
// break;
// }
//}
//
//static void Serialization_API_Usage(Material material, ShaderID id)
//{
// switch(id)
// {
// case ShaderID.Unlit:
// var serializedObject = new SerializedObject(material);
// AddSerializedInt(serializedObject, "former", 42);
// RenameSerializedScalar(serializedObject, "former", "new");
// Debug.Log(GetSerializedInt(serializedObject, "new"));
// RemoveSerializedInt(serializedObject, "new");
// serializedObject.ApplyModifiedProperties();
// break;
// }
//}
static void ZWriteForTransparent(Material material, HDShaderUtils.ShaderID id)
{
// For transparent materials, the ZWrite property that is now used is _TransparentZWrite.
if (material.GetSurfaceType() == SurfaceType.Transparent)
{
material.SetFloat(kTransparentZWrite, material.GetZWrite() ? 1.0f : 0.0f);
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void OnShaderGraphSaved(Shader shader, object saveContext)
{
// In case the shader is not HDRP
if (!(saveContext is HDSaveContext hdSaveContext))
{
return;
}
HDRenderPipeline.currentPipeline.ResetPathTracing();
if (!hdSaveContext.updateMaterials)
{
return;
}
// Iterate all Materials
string[] materialGuids = AssetDatabase.FindAssets(kMaterialFilter);
try
{
for (int i = 0, length = materialGuids.Length; i < length; i++)
{
// Only update progress bar every 10 materials
if (i % 10 == 9)
{
EditorUtility.DisplayProgressBar(
"Checking material dependencies...",
$"{i} / {length} materials.",
i / (float)(length - 1));
}
// Get Material object
string materialPath = AssetDatabase.GUIDToAssetPath(materialGuids[i]);
Material material = AssetDatabase.LoadAssetAtPath <Material>(materialPath);
// Reset keywords
if (material.shader.name == shader.name)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
material = null;
// Free the materials every 200 iterations, on big project loading all materials in memory can lead to a crash
if ((i % 200 == 0) && i != 0)
{
EditorUtility.UnloadUnusedAssetsImmediate(true);
}
}
}
finally
{
EditorUtility.ClearProgressBar();
EditorUtility.UnloadUnusedAssetsImmediate(true);
}
}
void DrawShaderGraphGUI()
{
// Filter out properties we don't want to draw:
PropertiesDefaultGUI(properties);
// If we change a property in a shadergraph, we trigger a material keyword reset
if (CheckPropertyChanged(properties))
{
foreach (var material in materials)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
}
if (properties.Length > 0)
{
EditorGUILayout.Space();
}
if ((m_Features & Features.DiffusionProfileAsset) != 0)
{
DrawDiffusionProfileUI();
}
if ((m_Features & Features.EnableInstancing) != 0)
{
materialEditor.EnableInstancingField();
}
if ((m_Features & Features.DoubleSidedGI) != 0)
{
// If the shader graph have a double sided flag, then we don't display this field.
// The double sided GI value will be synced with the double sided property during the SetupBaseUnlitKeywords()
if (!materials[0].HasProperty(kDoubleSidedEnable))
{
materialEditor.DoubleSidedGIField();
}
}
if ((m_Features & Features.EmissionGI) != 0)
{
DrawEmissionGI();
}
if ((m_Features & Features.MotionVector) != 0)
{
DrawMotionVectorToggle();
}
if ((m_Features & Features.ShadowMatte) != 0 && materials[0].HasProperty(kShadowMatteFilter))
{
DrawShadowMatteToggle();
}
}
internal static void ForceForwardEmissiveOnMaterialDisableInScene()
{
var materials = Resources.FindObjectsOfTypeAll <Material>();
foreach (var material in materials)
{
if (material.HasProperty(HDMaterialProperties.kForceForwardEmissive))
{
material.SetInt(HDMaterialProperties.kForceForwardEmissive, 0);
HDShaderUtils.ResetMaterialKeywords(material);
}
}
}
static void ExposeRefraction(Material material, HDShaderUtils.ShaderID id)
{
// Lit SG now have a shader feature for refraction instead of an hardcoded material
if (id == HDShaderUtils.ShaderID.SG_Lit)
{
// Sync the default refraction model from the shader graph to the shader
// We need to do this because the material may already have a refraction model information (from the Lit)
// In order to not break the rendering of the material, we patch the refraction model:
if (material.HasProperty(kRefractionModel))
{
var refractionModel = material.shader.GetPropertyDefaultFloatValue(material.shader.FindPropertyIndex(kRefractionModel));
material.SetFloat(kRefractionModel, refractionModel);
}
HDShaderUtils.ResetMaterialKeywords(material);
}
}
internal static void ForceForwardEmissiveOnMaterialEnableInSelection()
{
var selection = UnityEditor.Selection.objects;
foreach (var obj in selection)
{
if (obj is Material material)
{
if (material.HasProperty(HDMaterialProperties.kForceForwardEmissive))
{
material.SetInt(HDMaterialProperties.kForceForwardEmissive, 1);
HDShaderUtils.ResetMaterialKeywords(material);
}
}
}
}
static void OnShaderGraphSaved(Shader shader, object saveContext)
{
// In case the shader is not HDRP
if (!(saveContext is HDSaveContext hdSaveContext))
{
return;
}
HDRenderPipeline.currentPipeline?.ResetPathTracing();
if (!hdSaveContext.updateMaterials)
{
return;
}
// Iterate over all loaded Materials
Material[] materials = Resources.FindObjectsOfTypeAll <Material>();
try
{
for (int i = 0, length = materials.Length; i < length; i++)
{
// Only update progress bar every 10 materials
if (i % 10 == 9)
{
EditorUtility.DisplayProgressBar(
"Checking material dependencies...",
$"{i} / {length} materials.",
i / (float)(length - 1));
}
// Reset keywords
if (materials[i].shader.name == shader.name)
{
HDShaderUtils.ResetMaterialKeywords(materials[i]);
}
}
}
finally
{
EditorUtility.ClearProgressBar();
}
}
static void ShaderGraphStack(Material material, HDShaderUtils.ShaderID id)
{
Shader shader = material.shader;
if (shader.IsShaderGraph())
{
if (shader.TryGetMetadataOfType <HDMetadata>(out var obj))
{
// Material coming from old cross pipeline shader (Unlit and PBR) are not synchronize correctly with their
// shader graph. This code below ensure it is
if (obj.migrateFromOldCrossPipelineSG) // come from PBR or Unlit cross pipeline SG?
{
var defaultProperties = new Material(material.shader);
foreach (var floatToSync in s_ShadergraphStackFloatPropertiesToSynchronize)
{
if (material.HasProperty(floatToSync))
{
material.SetFloat(floatToSync, defaultProperties.GetFloat(floatToSync));
}
}
defaultProperties = null;
// Postprocess now that material is correctly sync
bool isTransparent = material.HasProperty("_SurfaceType") && material.GetFloat("_SurfaceType") > 0.0f;
bool alphaTest = material.HasProperty("_AlphaCutoffEnable") && material.GetFloat("_AlphaCutoffEnable") > 0.0f;
material.renderQueue = isTransparent ? (int)HDRenderQueue.Priority.Transparent :
alphaTest ? (int)HDRenderQueue.Priority.OpaqueAlphaTest : (int)HDRenderQueue.Priority.Opaque;
material.SetFloat("_RenderQueueType", isTransparent ? (float)HDRenderQueue.RenderQueueType.Transparent : (float)HDRenderQueue.RenderQueueType.Opaque);
}
}
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void ResetAllMaterialAssetsKeywords(float progressScale, float progressOffset)
{
var matIds = AssetDatabase.FindAssets("t:Material", new string[] { "Assets" }); // do not include packages
bool VCSEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
for (int i = 0, length = matIds.Length; i < length; i++)
{
var path = AssetDatabase.GUIDToAssetPath(matIds[i]);
var mat = AssetDatabase.LoadAssetAtPath <Material>(path);
EditorUtility.DisplayProgressBar(
"Setup material asset's Keywords...",
string.Format("{0} / {1} materials cleaned.", i, length),
(i / (float)(length - 1)) * progressScale + progressOffset);
CoreEditorUtils.CheckOutFile(VCSEnabled, mat);
var h = Debug.unityLogger.logHandler;
Debug.unityLogger.logHandler = new UnityContextualLogHandler(mat);
HDShaderUtils.ResetMaterialKeywords(mat);
Debug.unityLogger.logHandler = h;
}
}
static void Execute(CommandLineAction action)
{
switch (action.operation)
{
case CommandLineOperation.ResetMaterialKeywords:
{
Console.WriteLine("[HDEditorCLI][ResetMaterialKeywords] Starting material reset");
var matIds = AssetDatabase.FindAssets("t:Material");
for (int i = 0, length = matIds.Length; i < length; i++)
{
var path = AssetDatabase.GUIDToAssetPath(matIds[i]);
var mat = AssetDatabase.LoadAssetAtPath <Material>(path);
if (HDShaderUtils.ResetMaterialKeywords(mat))
{
Console.WriteLine("[HDEditorCLI][ResetMaterialKeywords] " + path);
}
}
break;
}
}
}
static void StencilRefactor(Material material, HDShaderUtils.ShaderID id)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
public static void HDSpeedTree8MaterialFinalizer(Material mat)
{
SetHDSpeedTree8Defaults(mat);
HDShaderUtils.ResetMaterialKeywords(mat);
}
public override void Convert(Material srcMaterial, Material dstMaterial)
{
base.Convert(srcMaterial, dstMaterial);
HDShaderUtils.ResetMaterialKeywords(dstMaterial);
}
static void ExposedDecalInputsFromShaderGraph(Material material, HDShaderUtils.ShaderID id)
{
if (id == HDShaderUtils.ShaderID.Decal)
{
// In order for the new properties (kAffectsAlbedo...) to be taken into account, we need to make it dirty so that the parameter is created first
HDShaderUtils.ResetMaterialKeywords(material);
var serializedMaterial = new SerializedObject(material);
// Note: the property must not exist in the .shader for RemoveSerializedFloat to work (otherwise it will be re-added)
const string kAlbedoMode = "_AlbedoMode";
float albedoMode = 1.0f;
if (TryFindProperty(serializedMaterial, kAlbedoMode, SerializedType.Float, out var propertyAlbedoMode, out _, out _))
{
albedoMode = propertyAlbedoMode.floatValue;
RemoveSerializedFloat(serializedMaterial, kAlbedoMode);
}
// For normal map we don't remove the property _NormalMap but just check if there is a texture assign and then enable _AffectNormal
const string kNormalMap = "_NormalMap";
float normalMap = 0.0f;
if (TryFindProperty(serializedMaterial, kNormalMap, SerializedType.Texture, out var propertyNormalTexture, out _, out _))
{
normalMap = propertyNormalTexture.FindPropertyRelative("m_Texture").objectReferenceValue != null ? 1.0f : 0.0f;
}
// For normal map we don't remove the property _NormalMap but just check if there is a texture assign and then enable _AffectNormal
const string kMaskMap = "_MaskMap";
float maskMap = 0.0f;
if (TryFindProperty(serializedMaterial, kMaskMap, SerializedType.Texture, out var propertyMaskMapTexture, out _, out _))
{
maskMap = propertyMaskMapTexture.FindPropertyRelative("m_Texture").objectReferenceValue != null ? 1.0f : 0.0f;
}
const string kMaskmapMetal = "_MaskmapMetal";
float maskMapMetal = 0.0f;
if (TryFindProperty(serializedMaterial, kMaskmapMetal, SerializedType.Float, out var propertyMaskMapMetal, out _, out _))
{
maskMapMetal = propertyMaskMapMetal.floatValue;
RemoveSerializedFloat(serializedMaterial, kMaskmapMetal);
}
const string kMaskmapAO = "_MaskmapAO";
float maskMapAO = 0.0f;
if (TryFindProperty(serializedMaterial, kMaskmapAO, SerializedType.Float, out var propertyMaskMapAO, out _, out _))
{
maskMapAO = propertyMaskMapAO.floatValue;
RemoveSerializedFloat(serializedMaterial, kMaskmapAO);
}
const string kMaskmapSmoothness = "_MaskmapSmoothness";
float maskMapSmoothness = 0.0f;
if (TryFindProperty(serializedMaterial, kMaskmapSmoothness, SerializedType.Float, out var propertyMaskMapSmoothness, out _, out _))
{
maskMapSmoothness = propertyMaskMapSmoothness.floatValue;
RemoveSerializedFloat(serializedMaterial, kMaskmapSmoothness);
}
const string kEmissive = "_Emissive";
float emissive = 0.0f;
if (TryFindProperty(serializedMaterial, kEmissive, SerializedType.Float, out var propertyEmissive, out _, out _))
{
emissive = propertyEmissive.floatValue;
RemoveSerializedFloat(serializedMaterial, kEmissive);
}
// Not used anymore, just removed
const string kMaskBlendMode = "_MaskBlendMode";
if (TryFindProperty(serializedMaterial, kMaskBlendMode, SerializedType.Float, out var propertyUnused, out _, out _))
{
RemoveSerializedFloat(serializedMaterial, kMaskBlendMode);
}
serializedMaterial.ApplyModifiedProperties();
// Now apply old value to new properties
const string kAffectAlbedo = "_AffectAlbedo";
material.SetFloat(kAffectAlbedo, albedoMode);
const string kAffectNormal = "_AffectNormal";
material.SetFloat(kAffectNormal, normalMap);
const string kAffectSmoothness = "_AffectSmoothness";
material.SetFloat(kAffectSmoothness, maskMapSmoothness * maskMap);
const string kAffectMetal = "_AffectMetal";
material.SetFloat(kAffectMetal, maskMapMetal * maskMap);
const string kAffectAO = "_AffectAO";
material.SetFloat(kAffectAO, maskMapAO * maskMap);
const string kAffectEmission = "_AffectEmission";
material.SetFloat(kAffectEmission, emissive);
// We can't erase obsolete disabled pass from already existing Material, so we need to re-enable all of them
const string s_MeshDecalsMStr = "DBufferMesh_M";
const string s_MeshDecalsSStr = "DBufferMesh_S";
const string s_MeshDecalsMSStr = "DBufferMesh_MS";
const string s_MeshDecalsAOStr = "DBufferMesh_AO";
const string s_MeshDecalsMAOStr = "DBufferMesh_MAO";
const string s_MeshDecalsAOSStr = "DBufferMesh_AOS";
const string s_MeshDecalsMAOSStr = "DBufferMesh_MAOS";
const string s_MeshDecals3RTStr = "DBufferMesh_3RT";
const string s_MeshDecalsForwardEmissive = "Mesh_Emissive";
material.SetShaderPassEnabled(s_MeshDecalsMStr, true);
material.SetShaderPassEnabled(s_MeshDecalsSStr, true);
material.SetShaderPassEnabled(s_MeshDecalsMSStr, true);
material.SetShaderPassEnabled(s_MeshDecalsAOStr, true);
material.SetShaderPassEnabled(s_MeshDecalsMAOStr, true);
material.SetShaderPassEnabled(s_MeshDecalsAOSStr, true);
material.SetShaderPassEnabled(s_MeshDecalsMAOSStr, true);
material.SetShaderPassEnabled(s_MeshDecals3RTStr, true);
material.SetShaderPassEnabled(s_MeshDecalsForwardEmissive, true);
}
if (id == HDShaderUtils.ShaderID.SG_Decal)
{
// We can't erase obsolete disabled pass from already existing Material, so we need to re-enable all of them
const string s_ShaderGraphMeshDecals4RT = "ShaderGraph_DBufferMesh4RT";
const string s_ShaderGraphMeshDecals3RT = "ShaderGraph_DBufferMesh3RT";
const string s_ShaderGraphMeshDecalForwardEmissive = "ShaderGraph_MeshEmissive";
material.SetShaderPassEnabled(s_ShaderGraphMeshDecals4RT, true);
material.SetShaderPassEnabled(s_ShaderGraphMeshDecals3RT, true);
material.SetShaderPassEnabled(s_ShaderGraphMeshDecalForwardEmissive, true);
}
if (id == HDShaderUtils.ShaderID.Decal || id == HDShaderUtils.ShaderID.SG_Decal)
{
HDShaderUtils.ResetMaterialKeywords(material);
}
}
public void OnPreprocessMaterialDescription(MaterialDescription description, Material material, AnimationClip[] clips)
{
var pipelineAsset = GraphicsSettings.currentRenderPipeline;
if (!pipelineAsset || pipelineAsset.GetType() != typeof(HDRenderPipelineAsset))
{
return;
}
var lowerCaseExtension = Path.GetExtension(assetPath).ToLower();
if (lowerCaseExtension != ".fbx" && lowerCaseExtension != ".obj" && lowerCaseExtension != ".dae" && lowerCaseExtension != ".obj" && lowerCaseExtension != ".blend" && lowerCaseExtension != ".mb" && lowerCaseExtension != ".ma" && lowerCaseExtension != ".max")
{
return;
}
var shader = AssetDatabase.LoadAssetAtPath <Shader>(k_ShaderPath);
if (shader == null)
{
return;
}
material.shader = shader;
Vector4 vectorProperty;
float floatProperty;
TexturePropertyDescription textureProperty;
bool isTransparent = false;
float opacity;
float transparencyFactor;
if (!description.TryGetProperty("Opacity", out opacity))
{
if (description.TryGetProperty("TransparencyFactor", out transparencyFactor))
{
opacity = transparencyFactor == 1.0f ? 1.0f : 1.0f - transparencyFactor;
}
if (opacity == 1.0f && description.TryGetProperty("TransparentColor", out vectorProperty))
{
opacity = vectorProperty.x == 1.0f ? 1.0f : 1.0f - vectorProperty.x;
}
}
if (opacity < 1.0f || (opacity == 1.0f && description.TryGetProperty("TransparentColor", out textureProperty)))
{
isTransparent = true;
}
else if (description.HasAnimationCurve("TransparencyFactor") || description.HasAnimationCurve("TransparentColor"))
{
isTransparent = true;
}
if (isTransparent)
{
material.SetFloat("_BlendMode", (float)BlendMode.Alpha);
material.SetFloat("_EnableBlendModePreserveSpecularLighting", 1.0f);
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
material.SetFloat("_SurfaceType", (float)SurfaceType.Transparent);
material.SetFloat("_Cutoff", .0f);
material.SetFloat("_AlphaCutoffEnable", 1.0f);
material.SetFloat("_AlphaCutoff", .0f);
material.SetFloat("_AlphaCutoffShadow", 1.0f);
material.SetFloat("_UseShadowThreshold", 1.0f);
}
else
{
material.renderQueue = -1;
}
if (description.TryGetProperty("ReflectionFactor", out floatProperty))
{
material.SetFloat("_Metallic", floatProperty);
}
if (description.TryGetProperty("DiffuseColor", out textureProperty) && textureProperty.texture != null)
{
Color diffuseColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
if (description.TryGetProperty("DiffuseFactor", out floatProperty))
{
diffuseColor *= floatProperty;
}
diffuseColor.a = opacity;
SetMaterialTextureProperty("_BaseColorMap", material, textureProperty);
material.SetColor("_BaseColor", diffuseColor);
}
else if (description.TryGetProperty("DiffuseColor", out vectorProperty))
{
Color diffuseColor = vectorProperty;
if (description.TryGetProperty("DiffuseFactor", out floatProperty))
{
diffuseColor *= floatProperty;
}
diffuseColor.a = opacity;
material.SetColor("_BaseColor", PlayerSettings.colorSpace == ColorSpace.Linear ? diffuseColor.gamma : diffuseColor);
}
if (description.TryGetProperty("Bump", out textureProperty) && textureProperty.texture != null)
{
SetMaterialTextureProperty("_BumpMap", material, textureProperty);
if (description.TryGetProperty("BumpFactor", out floatProperty))
{
material.SetFloat("_BumpScale", floatProperty);
}
}
else if (description.TryGetProperty("NormalMap", out textureProperty) && textureProperty.texture != null)
{
SetMaterialTextureProperty("_BumpMap", material, textureProperty);
if (description.TryGetProperty("BumpFactor", out floatProperty))
{
material.SetFloat("_BumpScale", floatProperty);
}
}
if (description.TryGetProperty("EmissiveColor", out textureProperty))
{
Color emissiveColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
material.SetColor("_EmissionColor", emissiveColor);
material.SetColor("_EmissiveColor", emissiveColor);
SetMaterialTextureProperty("_EmissionMap", material, textureProperty);
if (description.TryGetProperty("EmissiveFactor", out floatProperty) && floatProperty > 0.0f)
{
material.EnableKeyword("_EMISSION");
material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;
}
}
else if (description.TryGetProperty("EmissiveColor", out vectorProperty) && vectorProperty.magnitude > vectorProperty.w ||
description.HasAnimationCurve("EmissiveColor.x"))
{
if (description.TryGetProperty("EmissiveFactor", out floatProperty))
{
vectorProperty *= floatProperty;
}
material.SetColor("_EmissionColor", vectorProperty);
material.SetColor("_EmissiveColor", vectorProperty);
if (floatProperty > 0.0f)
{
material.EnableKeyword("_EMISSION");
material.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.RealtimeEmissive;
}
}
material.SetFloat("_Glossiness", 0.0f);
if (PlayerSettings.colorSpace == ColorSpace.Linear)
{
RemapAndTransformColorCurves(description, clips, "DiffuseColor", "_BaseColor", ConvertFloatLinearToGamma);
}
else
{
RemapColorCurves(description, clips, "DiffuseColor", "_BaseColor");
}
RemapTransparencyCurves(description, clips);
RemapColorCurves(description, clips, "EmissiveColor", "_EmissionColor");
RemapColorCurves(description, clips, "EmissiveColor", "_EmissiveColor");
HDShaderUtils.ResetMaterialKeywords(material);
}
static void RenderQueueUpgrade(Material material, HDShaderUtils.ShaderID id)
{
// In order for the ray tracing keyword to be taken into account, we need to make it dirty so that the parameter is created first
HDShaderUtils.ResetMaterialKeywords(material);
// Replace previous ray tracing render queue for opaque to regular opaque with raytracing
if (material.renderQueue == ((int)UnityEngine.Rendering.RenderQueue.GeometryLast + 20))
{
material.renderQueue = (int)HDRenderQueue.Priority.Opaque;
material.SetFloat(kRayTracing, 1.0f);
}
// Replace previous ray tracing render queue for transparent to regular transparent with raytracing
else if (material.renderQueue == 3900)
{
material.renderQueue = (int)HDRenderQueue.Priority.Transparent;
material.SetFloat(kRayTracing, 1.0f);
}
// For shader graphs, there is an additional pass we need to do
if (material.HasProperty("_RenderQueueType"))
{
int renderQueueType = (int)material.GetFloat("_RenderQueueType");
switch (renderQueueType)
{
// This was ray tracing opaque, should go back to opaque
case 3:
{
renderQueueType = 1;
}
break;
// If it was in the transparent range, reduce it by 1
case 4:
case 5:
case 6:
case 7:
{
renderQueueType = renderQueueType - 1;
}
break;
// If it was in the ray tracing transparent, should go back to transparent
case 8:
{
renderQueueType = renderQueueType - 4;
}
break;
// If it was in overlay should be reduced by 2
case 10:
{
renderQueueType = renderQueueType - 2;
}
break;
// background, opaque and AfterPostProcessOpaque are not impacted
default:
break;
}
// Push it back to the material
material.SetFloat("_RenderQueueType", (float)renderQueueType);
}
HDShaderUtils.ResetMaterialKeywords(material);
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
foreach (var asset in importedAssets)
{
if (!asset.ToLowerInvariant().EndsWith(".mat"))
{
continue;
}
var material = (Material)AssetDatabase.LoadAssetAtPath(asset, typeof(Material));
if (!HDShaderUtils.IsHDRPShader(material.shader, upgradable: true))
{
continue;
}
HDShaderUtils.ShaderID id = HDShaderUtils.GetShaderEnumFromShader(material.shader);
var latestVersion = k_Migrations.Length;
var wasUpgraded = false;
var assetVersions = AssetDatabase.LoadAllAssetsAtPath(asset);
AssetVersion assetVersion = null;
foreach (var subAsset in assetVersions)
{
if (subAsset != null && subAsset.GetType() == typeof(AssetVersion))
{
assetVersion = subAsset as AssetVersion;
break;
}
}
//subasset not found
if (!assetVersion)
{
wasUpgraded = true;
assetVersion = ScriptableObject.CreateInstance <AssetVersion>();
assetVersion.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector | HideFlags.NotEditable;
if (s_CreatedAssets.Contains(asset))
{
//just created
assetVersion.version = latestVersion;
s_CreatedAssets.Remove(asset);
//[TODO: remove comment once fixed]
//due to FB 1175514, this not work. It is being fixed though.
//delayed call of the following work in some case and cause infinite loop in other cases.
AssetDatabase.AddObjectToAsset(assetVersion, asset);
// Init material in case it's used before an inspector window is opened
HDShaderUtils.ResetMaterialKeywords(material);
}
else
{
//asset exist prior migration
assetVersion.version = 0;
AssetDatabase.AddObjectToAsset(assetVersion, asset);
}
}
//upgrade
while (assetVersion.version < latestVersion)
{
k_Migrations[assetVersion.version](material, id);
assetVersion.version++;
wasUpgraded = true;
}
if (wasUpgraded)
{
EditorUtility.SetDirty(assetVersion);
s_ImportedAssetThatNeedSaving.Add(asset);
s_NeedsSavingAssets = true;
}
}
}