protected virtual void OnEnable() { // Load the mixture graph: graph = MixtureEditorUtils.GetGraphAtPath(AssetDatabase.GetAssetPath(target)); variant = MixtureEditorUtils.GetVariantAtPath(AssetDatabase.GetAssetPath(target)); if (graph != null) { exposedParameterFactory = new ExposedParameterFieldFactory(graph); graph.onExposedParameterListChanged += UpdateExposedParameters; graph.onExposedParameterModified += UpdateExposedParameters; Undo.undoRedoPerformed += UpdateExposedParameters; } if (variant != null) { graph = variant.parentGraph; if (graph != null) { exposedParameterFactory = new ExposedParameterFieldFactory(variant.parentGraph); Editor.CreateCachedEditor(variant, typeof(MixtureVariantInspector), ref variantEditor); } else { Debug.LogError("Can't find parent graph for Mixture Variant " + variant); } } }
public override void OnInteractivePreviewGUI(Rect previewRect, GUIStyle background) { HandleZoomAndPan(previewRect); if (firstLockedPreviewTarget?.previewTexture != null && e.type == EventType.Repaint) { MixtureUtils.SetupDimensionKeyword(previewMaterial, firstLockedPreviewTarget.previewTexture.dimension); // Set texture property based on the dimension MixtureUtils.SetTextureWithDimension(previewMaterial, "_MainTex0", firstLockedPreviewTarget.previewTexture); MixtureUtils.SetTextureWithDimension(previewMaterial, "_MainTex1", secondLockedPreviewTarget.previewTexture); previewMaterial.SetFloat("_ComparisonSlider", compareSlider); previewMaterial.SetFloat("_ComparisonEnabled", compareEnabled ? 1 : 0); previewMaterial.SetFloat("_CompareMode", (int)compareMode); previewMaterial.SetFloat("_PreviewMip", mipLevel); previewMaterial.SetFloat("_YRatio", previewRect.height / previewRect.width); previewMaterial.SetFloat("_Zoom", zoom); previewMaterial.SetVector("_Pan", shaderPos / previewRect.size); previewMaterial.SetFloat("_FilterMode", (int)filterMode); previewMaterial.SetFloat("_Exp", exposure); previewMaterial.SetVector("_TextureSize", new Vector4(firstLockedPreviewTarget.previewTexture.width, firstLockedPreviewTarget.previewTexture.height, 1.0f / firstLockedPreviewTarget.previewTexture.width, 1.0f / firstLockedPreviewTarget.previewTexture.height)); previewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(channels)); previewMaterial.SetFloat("_IsSRGB0", firstLockedPreviewTarget is OutputNode o0 && o0.mainOutput.sRGB ? 1 : 0); previewMaterial.SetFloat("_IsSRGB1", secondLockedPreviewTarget is OutputNode o1 && o1.mainOutput.sRGB ? 1 : 0); EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, previewMaterial); } else { EditorGUI.DrawRect(previewRect, new Color(1, 0, 1, 1)); } }
public static bool OnBaseGraphOpened(int instanceID, int line) { var asset = EditorUtility.InstanceIDToObject(instanceID); if (asset is Texture) { // Check if the CustomRenderTexture we're opening is a Mixture graph var path = AssetDatabase.GetAssetPath(EditorUtility.InstanceIDToObject(instanceID)); var graph = MixtureEditorUtils.GetGraphAtPath(path); var variant = MixtureEditorUtils.GetVariantAtPath(path); graph ??= variant?.parentGraph; if (graph == null) { return(false); } MixtureGraphWindow.Open(graph); return(true); } else if (asset is MixtureVariant variant) { MixtureGraphWindow.Open(variant.parentGraph); } return(false); }
static void DrawMixtureSmallIcon(string assetGUID, Rect rect) { // If the icon is not small if (rect.height != 16) { return; } MixtureGraph graph; if (mixtureAssets.TryGetValue(assetGUID, out graph)) { DrawMixtureSmallIcon(rect, graph, Selection.Contains(graph.mainOutputTexture)); return; } if (mixtureVariants.TryGetValue(assetGUID, out var v)) { // TODO: draw the mixture variant icon DrawMixtureSmallIcon(rect, v, Selection.Contains(v.mainOutputTexture)); return; } string assetPath = AssetDatabase.GUIDToAssetPath(assetGUID); // Mixture assets are saved as .asset files if (!assetPath.EndsWith($".{MixtureAssetCallbacks.Extension}")) { return; } // ensure that the asset is a texture: var texture = AssetDatabase.LoadAssetAtPath <Texture>(assetPath); if (texture == null) { return; } // Check if the current texture is a mixture variant var variant = MixtureEditorUtils.GetVariantAtPath(assetPath); if (variant != null) { mixtureVariants.Add(assetGUID, variant); DrawMixtureSmallIcon(rect, variant, Selection.Contains(texture)); return; } // and then that it have a Mixture Graph as subasset graph = MixtureEditorUtils.GetGraphAtPath(assetPath); if (graph != null) { mixtureAssets.Add(assetGUID, graph); DrawMixtureSmallIcon(rect, graph, Selection.Contains(texture)); return; } }
public override void BuildContextualMenu(ContextualMenuPopulateEvent evt) { base.BuildContextualMenu(evt); string mode = graph.isRealtime ? "Static" : "Realtime"; evt.menu.AppendSeparator(); evt.menu.AppendAction($"Convert Mixture to {mode}", _ => MixtureEditorUtils.ToggleMode(graph), DropdownMenuAction.AlwaysEnabled); }
void DrawPreviewImage() { var node = nodeView.nodeTarget as MixtureNode; var previewRect = previewImage.layout; previewRect.position = Vector2.zero; switch (node.previewTexture.dimension) { case TextureDimension.Tex2D: MixtureUtils.texture2DPreviewMaterial.SetTexture("_MainTex", node.previewTexture); MixtureUtils.texture2DPreviewMaterial.SetVector("_Size", new Vector4(node.previewTexture.width, node.previewTexture.height, 1, 1)); MixtureUtils.texture2DPreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(node.previewMode)); MixtureUtils.texture2DPreviewMaterial.SetFloat("_PreviewMip", node.previewMip); MixtureUtils.texture2DPreviewMaterial.SetFloat("_EV100", node.previewEV100); MixtureUtils.texture2DPreviewMaterial.SetInt("_IsSRGB", node.previewSRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, node.previewTexture, MixtureUtils.texture2DPreviewMaterial, ScaleMode.ScaleToFit, 0, 0); } break; case TextureDimension.Tex3D: MixtureUtils.texture3DPreviewMaterial.SetTexture("_Texture3D", node.previewTexture); MixtureUtils.texture3DPreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(node.previewMode)); MixtureUtils.texture3DPreviewMaterial.SetFloat("_PreviewMip", node.previewMip); MixtureUtils.texture3DPreviewMaterial.SetFloat("_Depth", (node.previewSlice + 0.5f) / node.settings.GetResolvedDepth(graphView.graph)); MixtureUtils.texture3DPreviewMaterial.SetFloat("_EV100", node.previewEV100); MixtureUtils.texture3DPreviewMaterial.SetInt("_IsSRGB", node.previewSRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, MixtureUtils.texture3DPreviewMaterial, ScaleMode.ScaleToFit, 0, 0, ColorWriteMask.Red); } break; case TextureDimension.Cube: MixtureUtils.textureCubePreviewMaterial.SetTexture("_Cubemap", node.previewTexture); MixtureUtils.textureCubePreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(node.previewMode)); MixtureUtils.textureCubePreviewMaterial.SetFloat("_PreviewMip", node.previewMip); MixtureUtils.textureCubePreviewMaterial.SetFloat("_EV100", node.previewEV100); MixtureUtils.textureCubePreviewMaterial.SetInt("_IsSRGB", node.previewSRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, MixtureUtils.textureCubePreviewMaterial, ScaleMode.ScaleToFit, 0, 0); } break; default: Debug.LogError(node.previewTexture + " is not a supported type for preview"); break; } }
public override void Enable(bool fromInspector) { base.Enable(fromInspector); if (shaderNode.material != null && !owner.graph.IsObjectInGraph(shaderNode.material)) { // Check if the material we have is ours if (owner.graph.IsExternalSubAsset(shaderNode.material)) { shaderNode.material = new Material(shaderNode.material); shaderNode.material.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector; } owner.graph.AddObjectToGraph(shaderNode.material); } shaderSettings = new VisualElement(); var shaderField = AddControlField(nameof(ShaderNode.shader)) as ObjectField; shaderSettings.Add(shaderField); var shaderCreationUI = new VisualElement(); shaderSettings.Add(shaderCreationUI); UpdateShaderCreationUI(shaderCreationUI, shaderField); shaderField.RegisterValueChangedCallback((v) => { SetShader((Shader)v.newValue, shaderCreationUI, shaderField); }); if (!fromInspector) { if (shaderNode.shader != null) { shaderPath = AssetDatabase.GetAssetPath(shaderNode.shader); } if (!String.IsNullOrEmpty(shaderPath)) { lastModified = File.GetLastWriteTime(shaderPath); } var lastWriteDetector = schedule.Execute(DetectShaderChanges); lastWriteDetector.Every(200); InitializeDebug(); onPortDisconnected += ResetMaterialPropertyToDefault; } var materialIMGUI = new IMGUIContainer(() => MaterialGUI(fromInspector, shaderCreationUI, shaderField)); shaderSettings.Add(materialIMGUI); materialIMGUI.AddToClassList("MaterialInspector"); controlsContainer.Add(shaderSettings); MixtureEditorUtils.ScheduleAutoHide(materialIMGUI, owner); }
protected virtual void OnEnable() { // Load the mixture graph: graph = MixtureEditorUtils.GetGraphAtPath(AssetDatabase.GetAssetPath(target)); if (graph != null) { graph.onExposedParameterListChanged += UpdateExposedParameters; graph.onExposedParameterModified += UpdateExposedParameters; } }
protected virtual void DrawImGUIPreview(MixtureNode node, Rect previewRect, float currentSlice) { var outputNode = node as OutputNode; switch (node.previewTexture.dimension) { case TextureDimension.Tex2D: MixtureUtils.texture2DPreviewMaterial.SetTexture("_MainTex", node.previewTexture); MixtureUtils.texture2DPreviewMaterial.SetVector("_Size", new Vector4(node.previewTexture.width, node.previewTexture.height, 1, 1)); MixtureUtils.texture2DPreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(nodeTarget.previewMode)); MixtureUtils.texture2DPreviewMaterial.SetFloat("_PreviewMip", nodeTarget.previewMip); MixtureUtils.texture2DPreviewMaterial.SetFloat("_EV100", nodeTarget.previewEV100); MixtureUtils.texture2DPreviewMaterial.SetFloat("_IsSRGB", outputNode != null && outputNode.mainOutput.sRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, node.previewTexture, MixtureUtils.texture2DPreviewMaterial, ScaleMode.ScaleToFit, 0, 0); } break; case TextureDimension.Tex3D: MixtureUtils.texture3DPreviewMaterial.SetTexture("_Texture3D", node.previewTexture); MixtureUtils.texture3DPreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(nodeTarget.previewMode)); MixtureUtils.texture3DPreviewMaterial.SetFloat("_PreviewMip", nodeTarget.previewMip); MixtureUtils.texture3DPreviewMaterial.SetFloat("_Depth", (currentSlice + 0.5f) / nodeTarget.rtSettings.GetDepth(owner.graph)); MixtureUtils.texture3DPreviewMaterial.SetFloat("_EV100", nodeTarget.previewEV100); MixtureUtils.texture3DPreviewMaterial.SetFloat("_IsSRGB", outputNode != null && outputNode.mainOutput.sRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, MixtureUtils.texture3DPreviewMaterial, ScaleMode.ScaleToFit, 0, 0, ColorWriteMask.Red); } break; case TextureDimension.Cube: MixtureUtils.textureCubePreviewMaterial.SetTexture("_Cubemap", node.previewTexture); MixtureUtils.textureCubePreviewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(nodeTarget.previewMode)); MixtureUtils.textureCubePreviewMaterial.SetFloat("_PreviewMip", nodeTarget.previewMip); MixtureUtils.textureCubePreviewMaterial.SetFloat("_EV100", nodeTarget.previewEV100); MixtureUtils.textureCubePreviewMaterial.SetFloat("_IsSRGB", outputNode != null && outputNode.mainOutput.sRGB ? 1 : 0); if (Event.current.type == EventType.Repaint) { EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, MixtureUtils.textureCubePreviewMaterial, ScaleMode.ScaleToFit, 0, 0); } break; default: Debug.LogError(node.previewTexture + " is not a supported type for preview"); break; } }
public override void Enable(bool fromInspector) { base.Enable(fromInspector); if (!fromInspector) { if (fixedShaderNode.material != null && !owner.graph.IsObjectInGraph(fixedShaderNode.material)) { if (owner.graph.IsExternalSubAsset(fixedShaderNode.material)) { fixedShaderNode.material = new Material(fixedShaderNode.material); fixedShaderNode.material.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector; } if (fixedShaderNode.material.shader.name != ShaderNode.DefaultShaderName) { owner.graph.AddObjectToGraph(fixedShaderNode.material); } } if (fixedShaderNode.shader != null) { lastModified = File.GetLastWriteTime(AssetDatabase.GetAssetPath(fixedShaderNode.shader)); } var lastWriteDetector = schedule.Execute(DetectShaderChanges); lastWriteDetector.Every(200); InitializeDebug(); onPortDisconnected += ResetMaterialPropertyToDefault; } if (fixedShaderNode.displayMaterialInspector) { Action <bool> safeMaterialGUI = (bool init) => { // Copy fromInspector to avoid having the same value (lambda capture fromInspector pointer) bool f = fromInspector; if (!init) { MaterialGUI(f); } }; safeMaterialGUI(true); var materialIMGUI = new IMGUIContainer(() => safeMaterialGUI(false)); materialIMGUI.AddToClassList("MaterialInspector"); MixtureEditorUtils.ScheduleAutoHide(materialIMGUI, owner); controlsContainer.Add(materialIMGUI); } }
protected virtual void CreateNewShader(VisualElement shaderCreationUI, ObjectField shaderField) { // TODO: create a popupwindow instead of a context menu var menu = new GenericMenu(); var dim = (OutputDimension)shaderNode.settings.GetResolvedTextureDimension(owner.graph); #if MIXTURE_SHADERGRAPH GUIContent shaderGraphContent = EditorGUIUtility.TrTextContentWithIcon("Graph", Resources.Load <Texture2D>("sg_graph_icon@64")); menu.AddItem(shaderGraphContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderGraph(owner.graph, title, dim), shaderCreationUI, shaderField)); #endif GUIContent shaderTextContent = EditorGUIUtility.TrTextContentWithIcon("Text", "Shader Icon"); menu.AddItem(shaderTextContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderText(owner.graph, title, dim), shaderCreationUI, shaderField)); menu.ShowAsContext(); }
// By default isRealtime is false so we don't need to initialize it like in the realtime mixture create function public override MixtureGraph CreateMixtureGraphAsset() { var g = MixtureEditorUtils.GetGraphAtPath(template); g = ScriptableObject.Instantiate(g) as MixtureGraph; g.ClearObjectReferences(); foreach (var node in g.nodes) { // Duplicate all the materials from the template if (node is ShaderNode s && s.material != null) { s.material = new Material(s.material); s.material.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector; }
public static void BuildMixtureAssetBundle(BuildTarget buildTarget) { AssetBundleBuild buildMap = new AssetBundleBuild { assetBundleName = "MixtureAssetBundle" }; List <string> mixturePathes = new List <string>(); var db = ScriptableObject.CreateInstance <MixtureDatabase>(); foreach (var path in Directory.GetFiles("Assets", "*.asset", SearchOption.AllDirectories)) { AddMixtureToAssetBundle(path); } foreach (var path in Directory.GetFiles("Packages", "*.asset", SearchOption.AllDirectories)) { AddMixtureToAssetBundle(path); } void AddMixtureToAssetBundle(string path) { var graph = MixtureEditorUtils.GetGraphAtPath(path); if (graph != null) { if (graph.isRealtime) { db.realtimeGraphs.Add(graph); } else if (graph.embedInBuild) { db.staticGraphs.Add(graph); } } } buildMap.assetNames = mixturePathes.ToArray(); if (!Directory.Exists("Assets/Resources/Mixture")) { Directory.CreateDirectory("Assets/Resources/Mixture"); } AssetDatabase.DeleteAsset("Assets/Resources/Mixture/DataBase.asset"); AssetDatabase.CreateAsset(db, "Assets/Resources/Mixture/DataBase.asset"); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); }
public override void OnInteractivePreviewGUI(Rect previewRect, GUIStyle background) { HandleZoomAndPan(previewRect); if (mixtureInspector.firstLockedPreviewTarget?.previewTexture != null && e.type == EventType.Repaint) { mixtureInspector.volumeCameraMatrix = Matrix4x4.Rotate(Quaternion.Euler(mixtureInspector.cameraYAxis, mixtureInspector.cameraXAxis, 0)); MixtureUtils.SetupDimensionKeyword(previewMaterial, mixtureInspector.firstLockedPreviewTarget.previewTexture.dimension); // Set texture property based on the dimension MixtureUtils.SetTextureWithDimension(previewMaterial, "_MainTex0", mixtureInspector.firstLockedPreviewTarget.previewTexture); MixtureUtils.SetTextureWithDimension(previewMaterial, "_MainTex1", mixtureInspector.secondLockedPreviewTarget.previewTexture); previewMaterial.SetFloat("_ComparisonSlider", mixtureInspector.compareSlider); previewMaterial.SetFloat("_ComparisonSlider3D", mixtureInspector.compareSlider3D); previewMaterial.SetVector("_MouseUV", mixtureInspector.mouseUV); previewMaterial.SetMatrix("_CameraMatrix", mixtureInspector.volumeCameraMatrix); previewMaterial.SetFloat("_CameraZoom", mixtureInspector.cameraZoom); previewMaterial.SetFloat("_ComparisonEnabled", mixtureInspector.compareEnabled ? 1 : 0); previewMaterial.SetFloat("_CompareMode", (int)mixtureInspector.compareMode); previewMaterial.SetFloat("_PreviewMip", mixtureInspector.mipLevel); previewMaterial.SetFloat("_YRatio", previewRect.height / previewRect.width); previewMaterial.SetFloat("_Zoom", mixtureInspector.zoom); previewMaterial.SetVector("_Pan", mixtureInspector.shaderPos / previewRect.size); previewMaterial.SetFloat("_FilterMode", (int)mixtureInspector.filterMode); previewMaterial.SetFloat("_Exp", mixtureInspector.exposure); previewMaterial.SetVector("_TextureSize", new Vector4(mixtureInspector.firstLockedPreviewTarget.previewTexture.width, mixtureInspector.firstLockedPreviewTarget.previewTexture.height, 1.0f / mixtureInspector.firstLockedPreviewTarget.previewTexture.width, 1.0f / mixtureInspector.firstLockedPreviewTarget.previewTexture.height)); previewMaterial.SetVector("_Channels", MixtureEditorUtils.GetChannelsMask(mixtureInspector.channels)); previewMaterial.SetFloat("_IsSRGB0", mixtureInspector.firstLockedPreviewTarget is OutputNode o0 && o0.mainOutput.sRGB ? 1 : 0); previewMaterial.SetFloat("_IsSRGB1", mixtureInspector.secondLockedPreviewTarget is OutputNode o1 && o1.mainOutput.sRGB ? 1 : 0); previewMaterial.SetFloat("_PreserveAspect", mixtureInspector.preserveAspect ? 1 : 0); previewMaterial.SetFloat("_Texture3DMode", (int)mixtureInspector.texture3DPreviewMode); previewMaterial.SetFloat("_Density", mixtureInspector.texture3DDensity); previewMaterial.SetFloat("_SDFOffset", mixtureInspector.texture3DDistanceFieldOffset); previewMaterial.SetFloat("_SDFChannel", (int)mixtureInspector.sdfChannel); previewMaterial.SetFloat("_ShowCubeBackface", mixtureInspector.showCubeBackface ? 1 : 0); previewMaterial.SetFloat("_InvertSurface", mixtureInspector.invertSurface ? 1 : 0); previewMaterial.SetFloat("_VolumetricDensityChannel", mixtureInspector.volumetricDensityChannel); EditorGUI.DrawPreviewTexture(previewRect, Texture2D.whiteTexture, previewMaterial); } else { EditorGUI.DrawRect(previewRect, new Color(1, 0, 1, 1)); } }
static void DrawMixtureSmallIcon(string assetGUID, Rect rect) { // If the icon is not small if (rect.height != 16) { return; } MixtureGraph graph; if (mixtureAssets.TryGetValue(assetGUID, out graph)) { DrawMixtureSmallIcon(rect, graph); return; } string assetPath = AssetDatabase.GUIDToAssetPath(assetGUID); // Mixture assets are saved as .asset files if (!assetPath.EndsWith($".{MixtureAssetCallbacks.Extension}")) { return; } // ensure that the asset is a texture: var texture = AssetDatabase.LoadAssetAtPath <Texture>(assetPath); if (texture == null) { return; } // and then that it have a Mixture Graph as subasset graph = MixtureEditorUtils.GetGraphAtPath(assetPath); if (graph == null) { return; } mixtureAssets.Add(assetGUID, graph); DrawMixtureSmallIcon(rect, graph); }
public static void CreateMixtureVariant() { var selectedMixtures = Selection.GetFiltered <Texture>(SelectionMode.Assets); foreach (var mixtureTexture in selectedMixtures) { var graph = MixtureDatabase.GetGraphFromTexture(mixtureTexture); var variant = MixtureEditorUtils.GetVariantAtPath(AssetDatabase.GetAssetPath(mixtureTexture)); if (graph != null) { CreateMixtureVariant(graph, null); } else if (variant != null) { CreateMixtureVariant(null, variant); } } }
public static IEnumerable <MixtureTestCase> GetMixtureTestCases() { foreach (var assetPath in Directory.GetFiles(mixtureTestFolder, "*.asset", SearchOption.AllDirectories)) { var graph = MixtureEditorUtils.GetGraphAtPath(assetPath); string graphName = Path.GetFileNameWithoutExtension(assetPath); string referenceImagePath = Path.Combine(referenceImagesFolder, graphName + ".png"); var expectedImage = AssetDatabase.LoadAssetAtPath <Texture2D>(referenceImagePath); if (graph != null) { yield return(new MixtureTestCase { graph = graph, expected = expectedImage }); } } }
void UpdateShaderCreationUI() { shaderCreationUI.Clear(); if (shaderNode.shader == null) { shaderCreationUI.Add(new Button(CreateNewShader) { text = "New Shader" }); } else { shaderCreationUI.Add(new Button(OpenCurrentShader) { text = "Open" }); } void CreateNewShader() { // TODO: create a popupwindow instead of a context menu var menu = new GenericMenu(); var dim = (OutputDimension)shaderNode.rtSettings.GetTextureDimension(owner.graph); #if MIXTURE_SHADERGRAPH GUIContent shaderGraphContent = EditorGUIUtility.TrTextContentWithIcon("Graph", Resources.Load <Texture2D>("sg_graph_icon@64")); menu.AddItem(shaderGraphContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderGraph(title, dim))); #endif GUIContent shaderTextContent = EditorGUIUtility.TrTextContentWithIcon("Text", "Shader Icon"); menu.AddItem(shaderTextContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderText(title, dim))); menu.ShowAsContext(); } void OpenCurrentShader() { AssetDatabase.OpenAsset(shaderNode.shader); } }
public static bool CreateMixtureVariantEnabled() { var selectedMixtures = Selection.GetFiltered <Texture>(SelectionMode.Assets); int graphOrVariantCount = selectedMixtures.Count(m => MixtureDatabase.GetGraphFromTexture(m) != null || MixtureEditorUtils.GetVariantAtPath(AssetDatabase.GetAssetPath(m))); return((graphOrVariantCount) > 0); }
protected override void CreateNewShader(VisualElement shaderCreationUI, ObjectField shaderField) { SetShader(MixtureEditorUtils.CreateCustomMipMapShaderGraph(owner.graph, title), shaderCreationUI, shaderField); }