public void OnProcessShader(Shader shader, ShaderSnippetData snippetData, IList <ShaderCompilerData> compilerDataList)
{
#if PROFILE_BUILD
Profiler.BeginSample(k_ProcessShaderTag);
#endif
// We only want to perform shader variant stripping if the built-in render pipeline
// is the active render pipeline (i.e., there is no SRP asset in place).
RenderPipelineAsset rpAsset = GraphicsSettings.currentRenderPipeline;
if (rpAsset != null || compilerDataList == null || compilerDataList.Count == 0)
{
return;
}
double stripTimeMs = 0.0;
int prevVariantCount = compilerDataList.Count;
using (TimedScope.FromRef(ref stripTimeMs))
{
var inputShaderVariantCount = compilerDataList.Count;
for (int i = 0; i < inputShaderVariantCount;)
{
bool removeInput = true;
foreach (var supportedFeatures in ShaderBuildPreprocessor.supportedFeaturesList)
{
if (!StripUnused(supportedFeatures, shader, snippetData, compilerDataList[i]))
{
removeInput = false;
break;
}
}
// Remove at swap back
if (removeInput)
{
compilerDataList[i] = compilerDataList[--inputShaderVariantCount];
}
else
{
++i;
}
}
if (compilerDataList is List <ShaderCompilerData> inputDataList)
{
inputDataList.RemoveRange(inputShaderVariantCount, inputDataList.Count - inputShaderVariantCount);
}
else
{
for (int i = compilerDataList.Count - 1; i >= inputShaderVariantCount; --i)
{
compilerDataList.RemoveAt(i);
}
}
}
m_TotalVariantsInputCount += prevVariantCount;
m_TotalVariantsOutputCount += compilerDataList.Count;
LogShaderVariants(shader, snippetData, prevVariantCount, compilerDataList.Count);
#if PROFILE_BUILD
Profiler.EndSample();
#endif
shaderPreprocessed?.Invoke(shader, snippetData, prevVariantCount, stripTimeMs);
}
public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
{
return(renderPipelineAsset is LightweightRenderPipelineAsset);
}
public override bool WorksWithSRP(RenderPipelineAsset scriptableRenderPipeline) => true;
public void Initialize(string assetGuid)
{
try
{
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(assetGuid));
if (asset == null)
{
return;
}
if (!EditorUtility.IsPersistent(asset))
{
return;
}
if (selectedGuid == assetGuid)
{
return;
}
var path = AssetDatabase.GetAssetPath(asset);
var extension = Path.GetExtension(path);
Type graphType;
switch (extension)
{
case ".ShaderGraph":
graphType = typeof(MaterialGraph);
break;
case ".ShaderSubGraph":
graphType = typeof(SubGraph);
break;
default:
return;
}
selectedGuid = assetGuid;
var textGraph = File.ReadAllText(path, Encoding.UTF8);
graphObject = CreateInstance <GraphObject>();
graphObject.hideFlags = HideFlags.HideAndDontSave;
graphObject.graph = JsonUtility.FromJson(textGraph, graphType) as IGraph;
graphObject.graph.OnEnable();
graphObject.graph.ValidateGraph();
graphEditorView = new GraphEditorView(this, m_GraphObject.graph as AbstractMaterialGraph)
{
persistenceKey = selectedGuid,
assetName = asset.name.Split('/').Last()
};
graphEditorView.RegisterCallback <GeometryChangedEvent>(OnGeometryChanged);
titleContent = new GUIContent(asset.name.Split('/').Last());
Repaint();
}
catch (Exception)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
throw;
}
}
public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
{
return(renderPipelineAsset == null);
}
public static bool IsHDRP(RenderPipelineAsset asset)
{
return(asset != null &&
asset.GetType().Name.Equals("HDRenderPipelineAsset"));
}
public void Initialize(string assetGuid)
{
try
{
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(assetGuid));
if (asset == null)
{
return;
}
if (!EditorUtility.IsPersistent(asset))
{
return;
}
if (selectedGuid == assetGuid)
{
return;
}
var path = AssetDatabase.GetAssetPath(asset);
var extension = Path.GetExtension(path);
if (extension == null)
{
return;
}
// Path.GetExtension returns the extension prefixed with ".", so we remove it. We force lower case such that
// the comparison will be case-insensitive.
extension = extension.Substring(1).ToLowerInvariant();
bool isSubGraph;
switch (extension)
{
case ShaderGraphImporter.Extension:
isSubGraph = false;
break;
case ShaderSubGraphImporter.Extension:
isSubGraph = true;
break;
default:
return;
}
selectedGuid = assetGuid;
var textGraph = File.ReadAllText(path, Encoding.UTF8);
graphObject = CreateInstance <GraphObject>();
graphObject.hideFlags = HideFlags.HideAndDontSave;
graphObject.graph = JsonUtility.FromJson <GraphData>(textGraph);
graphObject.graph.isSubGraph = isSubGraph;
graphObject.graph.messageManager = messageManager;
graphObject.graph.OnEnable();
graphObject.graph.ValidateGraph();
graphEditorView = new GraphEditorView(this, m_GraphObject.graph, messageManager)
{
viewDataKey = selectedGuid,
assetName = asset.name.Split('/').Last()
};
titleContent = new GUIContent(asset.name.Split('/').Last());
Repaint();
}
catch (Exception)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
throw;
}
}
private void Clickedbutton(EventBase tab)
{
Button button = tab.target as Button;
if (button.name == "SupportButton")
{
supportTab.style.display = DisplayStyle.Flex;
aboutTab.style.display = DisplayStyle.None;
errorsTab.style.display = DisplayStyle.None;
acknowledgementsTab.style.display = DisplayStyle.None;
}
else if (button.name == "AboutButton")
{
supportTab.style.display = DisplayStyle.None;
aboutTab.style.display = DisplayStyle.Flex;
errorsTab.style.display = DisplayStyle.None;
acknowledgementsTab.style.display = DisplayStyle.None;
}
else if (button.name == "ConfigureButton")
{
supportTab.style.display = DisplayStyle.None;
aboutTab.style.display = DisplayStyle.None;
errorsTab.style.display = DisplayStyle.Flex;
acknowledgementsTab.style.display = DisplayStyle.None;
}
else if (button.name == "AcknowledgementsButton")
{
supportTab.style.display = DisplayStyle.None;
aboutTab.style.display = DisplayStyle.None;
errorsTab.style.display = DisplayStyle.None;
acknowledgementsTab.style.display = DisplayStyle.Flex;
}
else if (button.name == "Check")
{
SetUnchecked();
CheckUnityVersion();
}
else if (button.name == "Manual")
{
Application.OpenURL("https://alexander-ameye.gitbook.io/stylized-water-for-urp/support/troubleshooting");
}
else if (button.name == "Forum")
{
Application.OpenURL("https://forum.unity.com/threads/stylized-water-for-urp-desktop-mobile-released.846313/");
}
else if (button.name == "Contact")
{
Application.OpenURL("https://alexander-ameye.gitbook.io/stylized-water-for-urp/");
}
else if (button.name == "Review")
{
Application.OpenURL("https://assetstore.unity.com/packages/vfx/shaders/stylized-water-for-urp-162025");
}
else if (button.name == "Twitter")
{
Application.OpenURL("https://twitter.com/alexanderameye");
}
else if (button.name == "Website")
{
Application.OpenURL("https://alexanderameye.github.io/");
}
else if (button.name == "Unity Version Fix")
{
Application.OpenURL("https://unity3d.com/get-unity/download");
}
else if (button.name == "Active Renderer Fix")
{
SettingsService.OpenProjectSettings("Project/Graphics");
}
else if (button.name == "Depth Texture Fix")
{
#if UNIVERSAL_RENDERER
RenderPipelineAsset activeRenderer = GraphicsSettings.currentRenderPipeline;
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipeline = activeRenderer as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
EditorGUIUtility.PingObject(pipeline);
#endif
}
else if (button.name == "Opaque Texture Fix")
{
#if UNIVERSAL_RENDERER
RenderPipelineAsset activeRenderer = GraphicsSettings.currentRenderPipeline;
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipeline = activeRenderer as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
EditorGUIUtility.PingObject(pipeline);
#endif
}
else if (button.name == "URP Version Fix")
{
addRequest = Client.Add("com.unity.render-pipelines.universal");
EditorApplication.update += InstallURP;
activeRendererIcon.style.backgroundImage = Background.FromTexture2D(neutral);
activeRendererFix.style.visibility = Visibility.Hidden;
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
depthTextureFix.style.visibility = Visibility.Hidden;
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
opaqueTextureFix.style.visibility = Visibility.Hidden;
}
else if (button.name == "KeenanWoodall")
{
Application.OpenURL("https://twitter.com/keenanwoodall");
}
else if (button.name == "JoshSauter")
{
Application.OpenURL("https://github.com/JoshSauter");
}
}
static void FindErrors()
{
activeRendererIcon.style.backgroundImage = Background.FromTexture2D(neutral);
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
RenderPipelineAsset activeRenderer = GraphicsSettings.currentRenderPipeline;
if (activeRenderer == null)
{
activeRendererLabel.text = "Default";
depthTextureLabel.text = "Untested";
opaqueTextureLabel.text = "Untested";
activeRendererIcon.style.backgroundImage = Background.FromTexture2D(negative);
activeRendererFix.style.visibility = Visibility.Visible;
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
depthTextureFix.style.visibility = Visibility.Hidden;
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
opaqueTextureFix.style.visibility = Visibility.Hidden;
}
#if UNIVERSAL_RENDERER
else if (activeRenderer.GetType().Name.Contains("UniversalRenderPipelineAsset"))
{
activeRendererLabel.text = "Universal";
activeRendererIcon.style.backgroundImage = Background.FromTexture2D(positive);
activeRendererFix.style.visibility = Visibility.Hidden;
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipeline = activeRenderer as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
if (pipeline.supportsCameraDepthTexture)
{
depthTextureLabel.text = "Enabled";
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(positive);
depthTextureFix.style.visibility = Visibility.Hidden;
}
else
{
depthTextureLabel.text = "Disabled";
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(negative);
depthTextureFix.style.visibility = Visibility.Visible;
}
if (pipeline.supportsCameraOpaqueTexture)
{
opaqueTextureLabel.text = "Enabled";
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(positive);
opaqueTextureFix.style.visibility = Visibility.Hidden;
}
else
{
opaqueTextureLabel.text = "Disabled";
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(negative);
opaqueTextureFix.style.visibility = Visibility.Visible;
}
}
#endif
else
{
activeRendererLabel.text = "High-Definition";
depthTextureLabel.text = "Untested";
opaqueTextureLabel.text = "Untested";
activeRendererIcon.style.backgroundImage = Background.FromTexture2D(negative);
activeRendererFix.style.visibility = Visibility.Hidden;
depthTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
depthTextureFix.style.visibility = Visibility.Hidden;
opaqueTextureIcon.style.backgroundImage = Background.FromTexture2D(neutral);
opaqueTextureFix.style.visibility = Visibility.Hidden;
}
}
// Supports all SRPs bool ISubShader.IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset) => true;
public override bool IsPipelineCompatible(RenderPipelineAsset currentPipeline)
{
return(currentPipeline is UniversalRenderPipelineAsset);
}
public bool IsPipelineCompatible(RenderPipelineAsset currentPipeline)
{
return(currentPipeline is HDRenderPipelineAsset);
}
public override bool IsPipelineCompatible(RenderPipelineAsset currentPipeline)
{
return(currentPipeline != null);
}
public string GetSRPAssetAlias(RenderPipelineAsset srpAsset) => srpAssetAliases.Where(a => a.asset == srpAsset).FirstOrDefault()?.alias;
void Update()
{
if (m_HasError)
{
return;
}
if (focusedWindow == this && m_Deleted)
{
DisplayDeletedFromDiskDialog();
}
if (PlayerSettings.colorSpace != m_ColorSpace)
{
graphEditorView = null;
m_ColorSpace = PlayerSettings.colorSpace;
}
if (GraphicsSettings.renderPipelineAsset != m_RenderPipelineAsset)
{
graphEditorView = null;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
if (EditorGUIUtility.isProSkin != m_ProTheme)
{
if (graphObject != null && graphObject.graph != null)
{
Texture2D icon = GetThemeIcon(graphObject.graph);
// This is adding the icon at the front of the tab
titleContent = EditorGUIUtility.TrTextContentWithIcon(assetName, icon);
m_ProTheme = EditorGUIUtility.isProSkin;
}
}
if (m_PromptChangedOnDisk)
{
m_PromptChangedOnDisk = false;
DisplayChangedOnDiskDialog();
}
try
{
if (graphObject == null && selectedGuid != null)
{
var guid = selectedGuid;
selectedGuid = null;
Initialize(guid);
}
if (graphObject == null)
{
Close();
return;
}
var materialGraph = graphObject.graph as GraphData;
if (materialGraph == null)
{
return;
}
if (graphEditorView == null)
{
messageManager.ClearAll();
materialGraph.messageManager = messageManager;
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(selectedGuid));
graphEditorView = new GraphEditorView(this, materialGraph, messageManager)
{
viewDataKey = selectedGuid,
assetName = asset.name.Split('/').Last()
};
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
graphObject.Validate();
}
if (m_ChangedFileDependencies.Count > 0 && graphObject != null && graphObject.graph != null)
{
var subGraphNodes = graphObject.graph.GetNodes <SubGraphNode>();
foreach (var subGraphNode in subGraphNodes)
{
subGraphNode.Reload(m_ChangedFileDependencies);
}
if (subGraphNodes.Count() > 0)
{
// Keywords always need to be updated to test against variant limit
// No Keywords may indicate removal and this may have now made the Graph valid again
// Need to validate Graph to clear errors in this case
materialGraph.OnKeywordChanged();
}
foreach (var customFunctionNode in graphObject.graph.GetNodes <CustomFunctionNode>())
{
customFunctionNode.Reload(m_ChangedFileDependencies);
}
m_ChangedFileDependencies.Clear();
}
var wasUndoRedoPerformed = graphObject.wasUndoRedoPerformed;
if (wasUndoRedoPerformed)
{
graphEditorView.HandleGraphChanges();
graphObject.graph.ClearChanges();
graphObject.HandleUndoRedo();
}
if (graphObject.isDirty || wasUndoRedoPerformed)
{
UpdateTitle();
graphObject.isDirty = false;
}
graphEditorView.HandleGraphChanges();
graphObject.graph.ClearChanges();
}
catch (Exception e)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
Debug.LogException(e);
throw;
}
}
private void SetNewRenderPipelineAsset(RenderPipelineAsset rpAsset)
{
QualitySettings.renderPipeline = rpAsset;
}
public static bool IsURPOrLWRP(RenderPipelineAsset asset)
{
return(asset != null &&
(asset.GetType().Name.Equals("LightweightRenderPipelineAsset") ||
asset.GetType().Name.Equals("UniversalRenderPipelineAsset")));
}
public void Setup()
{
go = new GameObject();
camera = go.AddComponent <Camera>();
currentAsset = GraphicsSettings.renderPipelineAsset;
}
public static bool IsAssetContainsSRPOutlineFeature(RenderPipelineAsset asset)
{
var data = GetRenderer(asset);
return(data.rendererFeatures.Find(x => x is URPOutlineFeature) != null);
}
public abstract bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset);
void Update()
{
if (m_HasError)
{
return;
}
if (PlayerSettings.colorSpace != m_ColorSpace)
{
graphEditorView = null;
m_ColorSpace = PlayerSettings.colorSpace;
}
if (GraphicsSettings.renderPipelineAsset != m_RenderPipelineAsset)
{
graphEditorView = null;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
try
{
if (graphObject == null && selectedGuid != null)
{
var guid = selectedGuid;
selectedGuid = null;
Initialize(guid);
}
if (graphObject == null)
{
Close();
return;
}
var materialGraph = graphObject.graph as GraphData;
if (materialGraph == null)
{
return;
}
if (graphEditorView == null)
{
messageManager.ClearAll();
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(selectedGuid));
graphEditorView = new GraphEditorView(this, materialGraph, messageManager)
{
viewDataKey = selectedGuid,
assetName = asset.name.Split('/').Last()
};
materialGraph.messageManager = messageManager;
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
if (updatePreviewShaders)
{
m_GraphEditorView.UpdatePreviewShaders();
updatePreviewShaders = false;
}
graphEditorView.HandleGraphChanges();
graphObject.graph.ClearChanges();
Repaint();
}
catch (Exception e)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
Debug.LogException(e);
throw;
}
}
public void OnInspectorGUI()
{
m_SerializedRenderers.Update();
if (m_TransparentPriority != null)
{
EditorGUILayout.PropertyField(m_TransparentPriority, Contents.rendererPriorityStyle);
}
if (m_RenderingLayerMask != null)
{
RenderPipelineAsset srpAsset = GraphicsSettings.renderPipelineAsset;
if (srpAsset != null)
{
var layerNames = srpAsset.renderingLayerMaskNames;
if (layerNames != null)
{
var mask = (int)m_Renderers[0].renderingLayerMask;
var rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, Contents.renderingLayerMaskStyle, m_RenderingLayerMask);
EditorGUI.BeginChangeCheck();
mask = EditorGUI.MaskField(rect, Contents.renderingLayerMaskStyle, mask, layerNames);
if (EditorGUI.EndChangeCheck())
{
m_RenderingLayerMask.intValue = mask;
}
EditorGUI.EndProperty();
}
}
}
if (m_LightProbeUsage != null)
{
Rect r = EditorGUILayout.GetControlRect(true, EditorGUI.kSingleLineHeight, EditorStyles.popup);
EditorGUI.BeginProperty(r, Contents.lightProbeUsageStyle, m_LightProbeUsage);
EditorGUI.BeginChangeCheck();
var newValue = EditorGUI.EnumPopup(r, Contents.lightProbeUsageStyle, (LightProbeUsage)m_LightProbeUsage.intValue);
if (EditorGUI.EndChangeCheck())
{
m_LightProbeUsage.intValue = (int)(LightProbeUsage)newValue;
}
EditorGUI.EndProperty();
}
if (!m_LightProbeUsage.hasMultipleDifferentValues)
{
if (m_LightProbeUsage.intValue == (int)LightProbeUsage.UseProxyVolume)
{
EditorGUILayout.PropertyField(m_LightProbeVolumeOverride, Contents.lightProbeVolumeOverrideStyle);
}
else if (m_LightProbeUsage.intValue == (int)LightProbeUsage.BlendProbes)
{
EditorGUILayout.PropertyField(m_ProbeAnchor, Contents.lightProbeAnchorStyle);
}
}
m_SerializedRenderers.ApplyModifiedProperties();
}
void Update()
{
if (m_HasError)
{
return;
}
if (PlayerSettings.colorSpace != m_ColorSpace)
{
graphEditorView = null;
m_ColorSpace = PlayerSettings.colorSpace;
}
if (GraphicsSettings.renderPipelineAsset != m_RenderPipelineAsset)
{
graphEditorView = null;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
try
{
if (graphObject == null && selectedGuid != null)
{
var guid = selectedGuid;
selectedGuid = null;
Initialize(guid);
}
if (graphObject == null)
{
Close();
return;
}
var materialGraph = graphObject.graph as AbstractMaterialGraph;
if (materialGraph == null)
{
return;
}
if (graphEditorView == null)
{
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(selectedGuid));
graphEditorView = new GraphEditorView(this, materialGraph)
{
persistenceKey = selectedGuid,
assetName = asset.name.Split('/').Last()
};
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
if (forceRedrawPreviews)
{
// Redraw all previews
foreach (INode node in m_GraphObject.graph.GetNodes <INode>())
{
node.Dirty(ModificationScope.Node);
}
forceRedrawPreviews = false;
}
graphEditorView.HandleGraphChanges();
graphObject.graph.ClearChanges();
}
catch (Exception e)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
Debug.LogException(e);
throw;
}
}
public void Initialize(string assetGuid)
{
try
{
EditorApplication.wantsToQuit -= PromptSaveIfDirtyOnQuit;
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(assetGuid));
if (asset == null)
{
return;
}
if (!EditorUtility.IsPersistent(asset))
{
return;
}
if (selectedGuid == assetGuid)
{
return;
}
var path = AssetDatabase.GetAssetPath(asset);
var extension = Path.GetExtension(path);
if (extension == null)
{
return;
}
// Path.GetExtension returns the extension prefixed with ".", so we remove it. We force lower case such that
// the comparison will be case-insensitive.
extension = extension.Substring(1).ToLowerInvariant();
bool isSubGraph;
switch (extension)
{
case ShaderGraphImporter.Extension:
isSubGraph = false;
break;
case ShaderSubGraphImporter.Extension:
isSubGraph = true;
break;
default:
return;
}
selectedGuid = assetGuid;
using (GraphLoadMarker.Auto())
{
m_LastSerializedFileContents = File.ReadAllText(path, Encoding.UTF8);
graphObject = CreateInstance <GraphObject>();
graphObject.hideFlags = HideFlags.HideAndDontSave;
graphObject.graph = new GraphData
{
assetGuid = assetGuid, isSubGraph = isSubGraph, messageManager = messageManager
};
MultiJson.Deserialize(graphObject.graph, m_LastSerializedFileContents);
graphObject.graph.OnEnable();
graphObject.graph.ValidateGraph();
}
using (CreateGraphEditorViewMarker.Auto())
{
graphEditorView = new GraphEditorView(this, m_GraphObject.graph, messageManager)
{
viewDataKey = selectedGuid,
};
}
UpdateTitle();
Repaint();
EditorApplication.wantsToQuit += PromptSaveIfDirtyOnQuit;
}
catch (Exception)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
throw;
}
}
public abstract bool WorksWithSRP(RenderPipelineAsset scriptableRenderPipeline);
void Update()
{
if (m_HasError)
{
return;
}
bool updateTitle = false;
if (m_AssetMaybeDeleted)
{
m_AssetMaybeDeleted = false;
if (AssetFileExists())
{
// it exists... just to be sure, let's check if it changed
m_AssetMaybeChangedOnDisk = true;
}
else
{
// it was really deleted, ask the user what to do
bool handled = DisplayDeletedFromDiskDialog(true);
}
updateTitle = true;
}
if (PlayerSettings.colorSpace != m_ColorSpace)
{
graphEditorView = null;
m_ColorSpace = PlayerSettings.colorSpace;
}
if (GraphicsSettings.renderPipelineAsset != m_RenderPipelineAsset)
{
graphEditorView = null;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
}
if (EditorGUIUtility.isProSkin != m_ProTheme)
{
if (graphObject != null && graphObject.graph != null)
{
updateTitle = true; // trigger icon swap
m_ProTheme = EditorGUIUtility.isProSkin;
}
}
if (m_AssetMaybeChangedOnDisk)
{
m_AssetMaybeChangedOnDisk = false;
// if we don't have any graph, then it doesn't really matter if the file on disk changed or not
// as we're going to reload it below anyways
if (graphObject?.graph != null)
{
// check if it actually did change on disk
if (FileOnDiskHasChanged())
{
// don't worry people about "losing changes" unless there are changes to lose
bool graphChanged = GraphHasChangedSinceLastSerialization();
if (EditorUtility.DisplayDialog(
"Graph has changed on disk",
AssetDatabase.GUIDToAssetPath(selectedGuid) + "\n\n" +
(graphChanged ? "Do you want to reload it and lose the changes made in the graph?" : "Do you want to reload it?"),
graphChanged ? "Discard Changes And Reload" : "Reload",
"Don't Reload"))
{
// clear graph, trigger reload
graphObject = null;
}
}
}
updateTitle = true;
}
try
{
if (graphObject == null && selectedGuid != null)
{
var guid = selectedGuid;
selectedGuid = null;
Initialize(guid);
}
if (graphObject == null)
{
Close();
return;
}
var materialGraph = graphObject.graph as GraphData;
if (materialGraph == null)
{
return;
}
if (graphEditorView == null)
{
messageManager.ClearAll();
materialGraph.messageManager = messageManager;
var asset = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(selectedGuid));
graphEditorView = new GraphEditorView(this, materialGraph, messageManager)
{
viewDataKey = selectedGuid,
};
m_ColorSpace = PlayerSettings.colorSpace;
m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
graphObject.Validate();
// update blackboard title for the new graphEditorView
updateTitle = true;
}
if (m_ChangedFileDependencies.Count > 0 && graphObject != null && graphObject.graph != null)
{
bool reloadedSomething = false;
var subGraphNodes = graphObject.graph.GetNodes <SubGraphNode>();
foreach (var subGraphNode in subGraphNodes)
{
var reloaded = subGraphNode.Reload(m_ChangedFileDependencies);
reloadedSomething |= reloaded;
}
if (subGraphNodes.Count() > 0)
{
// Keywords always need to be updated to test against variant limit
// No Keywords may indicate removal and this may have now made the Graph valid again
// Need to validate Graph to clear errors in this case
materialGraph.OnKeywordChanged();
}
foreach (var customFunctionNode in graphObject.graph.GetNodes <CustomFunctionNode>())
{
var reloaded = customFunctionNode.Reload(m_ChangedFileDependencies);
reloadedSomething |= reloaded;
}
// reloading files may change serilization
if (reloadedSomething)
{
updateTitle = true;
}
m_ChangedFileDependencies.Clear();
}
var wasUndoRedoPerformed = graphObject.wasUndoRedoPerformed;
if (wasUndoRedoPerformed)
{
graphEditorView.HandleGraphChanges(true);
graphObject.graph.ClearChanges();
graphObject.HandleUndoRedo();
}
if (graphObject.isDirty || wasUndoRedoPerformed)
{
updateTitle = true;
graphObject.isDirty = false;
}
// Called again to handle changes from deserialization in case an undo/redo was performed
graphEditorView.HandleGraphChanges(wasUndoRedoPerformed);
graphObject.graph.ClearChanges();
if (updateTitle)
{
UpdateTitle();
}
}
catch (Exception e)
{
m_HasError = true;
m_GraphEditorView = null;
graphObject = null;
Debug.LogException(e);
throw;
}
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
var renderer = serializedObject.targetObject as Renderer;
EditorGUI.BeginChangeCheck();
RenderMode renderMode = (RenderMode)GUIPopup(s_Texts.renderMode, m_RenderMode, s_Texts.particleTypes);
bool renderModeChanged = EditorGUI.EndChangeCheck();
if (!m_RenderMode.hasMultipleDifferentValues)
{
if (renderMode == RenderMode.Mesh)
{
GUIPopup(s_Texts.meshDistribution, m_MeshDistribution, s_Texts.meshDistributionOptions);
DoListOfMeshesGUI();
if (renderModeChanged && m_Meshes[0].objectReferenceInstanceIDValue == 0 && !m_Meshes[0].hasMultipleDifferentValues)
{
m_Meshes[0].objectReferenceValue = Resources.GetBuiltinResource(typeof(Mesh), "Cube.fbx");
}
}
else if (renderMode == RenderMode.Stretch3D)
{
EditorGUI.indentLevel++;
GUIFloat(s_Texts.cameraSpeedScale, m_CameraVelocityScale);
GUIFloat(s_Texts.speedScale, m_VelocityScale);
GUIFloat(s_Texts.lengthScale, m_LengthScale);
GUIToggle(s_Texts.freeformStretching, m_FreeformStretching);
if (m_FreeformStretching.boolValue && !m_FreeformStretching.hasMultipleDifferentValues)
{
GUIToggle(s_Texts.rotateWithStretchDirection, m_RotateWithStretchDirection);
}
else
{
using (new EditorGUI.DisabledScope(true))
{
GUIToggle(s_Texts.rotateWithStretchDirection, true);
}
}
EditorGUI.indentLevel--;
}
if (renderMode != RenderMode.None)
{
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.normalDirection, m_NormalDirection);
}
}
}
if (renderMode != RenderMode.None)
{
if (m_Material != null) // The renderer's material list could be empty
{
GUIObject(s_Texts.material, m_Material);
}
}
var trailMaterial = serializedObject.FindProperty("m_Materials.Array.data[1]"); // Optional - may fail
if (trailMaterial != null) // Only show if the system has a second material slot
{
GUIObject(s_Texts.trailMaterial, trailMaterial);
}
if (renderMode != RenderMode.None)
{
if (!m_RenderMode.hasMultipleDifferentValues)
{
GUIPopup(s_Texts.sortMode, m_SortMode, s_Texts.sortTypes);
if (renderer != null && SortingGroup.invalidSortingGroupID != renderer.sortingGroupID)
{
using (new EditorGUI.DisabledScope(true))
GUIFloat(s_Texts.sortingFudgeDisabledDueToSortingGroup, m_SortingFudge);
}
else
{
GUIFloat(s_Texts.sortingFudge, m_SortingFudge);
}
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.minParticleSize, m_MinParticleSize);
GUIFloat(s_Texts.maxParticleSize, m_MaxParticleSize);
}
if (renderMode == RenderMode.Billboard || renderMode == RenderMode.Mesh)
{
bool anyAlignToDirection = m_ParticleSystemUI.m_ParticleSystems.FirstOrDefault(o => o.shape.enabled && o.shape.alignToDirection) != null;
if (anyAlignToDirection)
{
using (new EditorGUI.DisabledScope(true))
{
GUIPopup(s_Texts.space, 0, s_Texts.localSpace); // force to "Local"
}
GUIContent info = EditorGUIUtility.TrTextContent("Using Align to Direction in the Shape Module forces the system to be rendered using Local Render Alignment.");
EditorGUILayout.HelpBox(info.text, MessageType.Info, true);
}
else
{
GUIPopup(s_Texts.space, m_RenderAlignment, s_Texts.spaces);
}
}
if (renderMode == RenderMode.Mesh)
{
GUIVector3Field(s_Texts.flipMeshes, m_Flip);
}
else
{
GUIVector3Field(s_Texts.flip, m_Flip);
}
if (renderMode == RenderMode.Billboard)
{
GUIToggle(s_Texts.allowRoll, m_AllowRoll);
}
if (renderMode == RenderMode.Mesh && SupportedRenderingFeatures.active.particleSystemInstancing)
{
GUIToggle(s_Texts.enableGPUInstancing, m_EnableGPUInstancing);
if (!m_ParticleSystemUI.multiEdit && m_EnableGPUInstancing.boolValue)
{
Material materialAsset = m_Material?.objectReferenceValue as Material;
Material trailMaterialAsset = trailMaterial?.objectReferenceValue as Material;
if (materialAsset != null && trailMaterialAsset != null)
{
if (trailMaterialAsset.shader == materialAsset.shader)
{
if (ShaderUtil.HasProceduralInstancing(materialAsset.shader))
{
EditorGUILayout.HelpBox(s_Texts.meshGPUInstancingTrailsWarning.text, MessageType.Error, true);
}
}
}
}
}
}
GUIVector3Field(s_Texts.pivot, m_Pivot);
if (EditorGUIUtility.comparisonViewMode == EditorGUIUtility.ComparisonViewMode.None)
{
EditorGUI.BeginChangeCheck();
s_VisualizePivot = GUIToggle(s_Texts.visualizePivot, s_VisualizePivot);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetBool("VisualizePivot", s_VisualizePivot);
}
}
GUIPopup(s_Texts.maskingMode, m_MaskInteraction, s_Texts.maskInteractions);
GUIToggle(s_Texts.applyActiveColorSpace, m_ApplyActiveColorSpace);
if (GUIToggle(s_Texts.useCustomVertexStreams, m_UseCustomVertexStreams))
{
DoVertexStreamsGUI(renderMode);
}
}
EditorGUILayout.Space();
GUIPopup(s_Texts.castShadows, m_CastShadows, EditorGUIUtility.TempContent(m_CastShadows.enumDisplayNames));
if (m_CastShadows.hasMultipleDifferentValues || m_CastShadows.intValue != 0)
{
RenderPipelineAsset srpAsset = GraphicsSettings.currentRenderPipeline;
if (srpAsset != null)
{
GUIToggle(s_Texts.staticShadowCaster, m_StaticShadowCaster);
}
}
if (SupportedRenderingFeatures.active.receiveShadows)
{
// Disable ReceiveShadows options for Deferred rendering path
if (SceneView.IsUsingDeferredRenderingPath())
{
using (new EditorGUI.DisabledScope(true)) { GUIToggle(s_Texts.receiveShadows, true); }
}
else
{
GUIToggle(s_Texts.receiveShadows, m_ReceiveShadows);
}
}
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.shadowBias, m_ShadowBias);
}
if (SupportedRenderingFeatures.active.motionVectors)
{
GUIPopup(s_Texts.motionVectors, m_MotionVectors, s_Texts.motionVectorOptions);
}
GUISortingLayerField(s_Texts.sortingLayer, m_SortingLayerID);
GUIInt(s_Texts.sortingOrder, m_SortingOrder);
List <ParticleSystemRenderer> renderers = new List <ParticleSystemRenderer>();
foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems)
{
renderers.Add(ps.GetComponent <ParticleSystemRenderer>());
}
var renderersArray = renderers.ToArray();
m_Probes.OnGUI(renderersArray, renderers.FirstOrDefault(), true);
RendererEditorBase.DrawRenderingLayer(m_RenderingLayerMask, renderer, renderersArray, true);
RendererEditorBase.DrawRendererPriority(m_RendererPriority, true);
}
public override bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
{
return(true);
}
public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
{
return(renderPipelineAsset is UniversalRenderPipelineAsset);
}
void SetPipeline(RenderPipelineAsset pipe)
{
GraphicsSettings.renderPipelineAsset = pipe;
}
