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; }