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