internal static Rect GetEditorMainWindowPos()
{
if (s_MainWindow == null)
{
var containerWinType = GetAllDerivedTypes(typeof(ScriptableObject)).FirstOrDefault(t => t.Name == "ContainerWindow");
if (containerWinType == null)
{
throw new MissingMemberException("Can't find internal type ContainerWindow. Maybe something has changed inside Unity");
}
var showModeField = containerWinType.GetField("m_ShowMode", BindingFlags.NonPublic | BindingFlags.Instance);
if (showModeField == null)
{
throw new MissingFieldException("Can't find internal fields 'm_ShowMode'. Maybe something has changed inside Unity");
}
var windows = Resources.FindObjectsOfTypeAll(containerWinType);
foreach (var win in windows)
{
var showMode = (int)showModeField.GetValue(win);
if (showMode == 4) // main window
{
s_MainWindow = win;
break;
}
}
}
if (s_MainWindow == null)
{
return(new Rect(0, 0, 800, 600));
}
var positionProperty = s_MainWindow.GetType().GetProperty("position", BindingFlags.Public | BindingFlags.Instance);
if (positionProperty == null)
{
throw new MissingFieldException("Can't find internal fields 'position'. Maybe something has changed inside Unity.");
}
return((Rect)positionProperty.GetValue(s_MainWindow, null));
}
public ConstValue(Type type)
{
if (type == typeof(string))
{
Type = new SType(typeof(LText));
Value = new LText(true, "");
return;
}
Type = new SType(type);
if (type.IsValueType)
{
Value = Activator.CreateInstance(type);
}
else
{
_value = null;
_valueString = "null";
_unityObject = null;
}
}
public static string GetAssetPathNonResource(UnityEngine.Object rsrc)
{
if (rsrc == null)
{
return("");
}
var path = AssetDatabase.GetAssetPath(rsrc);
while (String.IsNullOrEmpty(path))
{
var parent = PrefabUtility.GetPrefabParent(rsrc);
if (parent == null)
{
break;
}
path = AssetDatabase.GetAssetPath(parent);
rsrc = parent;
}
return(path);
}
public bool Initialize(List <Framework.Parameter> parameters, BindingContext context, UnityEngine.Object target)
{
Parameters = parameters;
Provider = context.Provider;
Binder = context.Binder;
EditorTarget = target;
var isOk = IsValid();
if (isOk && ListDrawer == null)
{
ListDrawer = new UnityEditorInternal.ReorderableList
(
Parameters,
typeof(Framework.Parameter),
false,
true,
false,
false
);
ListDrawer.drawHeaderCallback += rect =>
{
var oldColor = GUI.color;
GUI.color = Color.white;
GUI.Label(rect, "Parameter Bindings", EditorStyles.whiteLabel);
GUI.color = oldColor;
};
ListDrawer.drawElementBackgroundCallback += (rect, index, active, focused) => { };
ListDrawer.elementHeight = BIND_ENTRY_HEIGHT;
ListDrawer.showDefaultBackground = false;
ListDrawer.drawElementCallback += OnDrawBinding;
}
return(isOk);
}
/// <summary>
/// Instantiate the specified _obj.
/// </summary>
/// <param name="_obj">_obj.</param>
private UnityEngine.Object Instantiate(UnityEngine.Object _obj)
{
return(Instantiate(_obj, null));
}
public UnityEngine.Object GetAsset()
{
UnityEngine.Object asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
return(asset);
}
public void LogException(Exception exception, UnityEngine.Object context)
{
_log.Write(GetPrefix(LogType.Exception), 0, Framework.Log.FormatException(exception));
_native.LogException(exception, context);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderMessages(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
var sourceAssetDependencyPaths = new List <string>();
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(), assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
Shader shader = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths, graph);
#if UNITY_2021_1_OR_NEWER
// 2021.1 or later is guaranteed to have the new version of this function
shader = ShaderUtil.CreateShaderAsset(ctx, text, false);
#else
// earlier builds of Unity may or may not have it
// here we try to invoke the new version via reflection
var createShaderAssetMethod = typeof(ShaderUtil).GetMethod(
"CreateShaderAsset",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.ExactBinding,
null,
new Type[] { typeof(AssetImportContext), typeof(string), typeof(bool) },
null);
if (createShaderAssetMethod != null)
{
shader = createShaderAssetMethod.Invoke(null, new Object[] { ctx, text, false }) as Shader;
}
else
{
// method doesn't exist in this version of Unity, call old version
// this doesn't create dependencies properly, but is the best that we can do
shader = ShaderUtil.CreateShaderAsset(text, false);
}
#endif
if (graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
EditorMaterialUtility.SetShaderDefaults(
shader,
configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
EditorMaterialUtility.SetShaderNonModifiableDefaults(
shader,
configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
}
UnityEngine.Object mainObject = shader;
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon@64");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
var deps = GatherDependenciesFromSourceFile(ctx.assetPath);
foreach (string dependency in deps)
{
sgMetadata.assetDependencies.Add(AssetDatabase.LoadAssetAtPath(dependency, typeof(UnityEngine.Object)));
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}", mainObject);
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
//===============================//
// Logic
//===============================//
public FoldoutAttributeHandler(UnityEngine.Object target, SerializedObject serializedObject)
{
this.target = target;
this.serializedObject = serializedObject;
}
static void DrawIconTextureSlot(Rect elementRect, int row, DrawableResourceData data, ImageSize size, NotificationIconType newType, string newId, UnityEngine.Object target)
{
Rect elementContentRect = GetContentRect(elementRect, 6f, 12f);
float errorMsgWidth = elementRect.width - kSlotSize * 3;
var textureRect = new Rect(elementContentRect.width - (kMaxPreviewSize * 2 - kIconSpacing * 5),
elementContentRect.y + kIconSpacing * row + kSlotSize * row, kMaxPreviewSize, kSlotSize);
var errorBoxRect = GetContentRect(
new Rect(elementContentRect.x,
elementContentRect.y + kIconSpacing * row + kSlotSize * row, errorMsgWidth, kSlotSize),
4f, 4f);
Rect previewTextureRect = new Rect(elementContentRect.width - (kMaxPreviewSize - kIconSpacing * 5),
elementContentRect.y + kIconSpacing * row + kSlotSize * row, kMaxPreviewSize, kSlotSize);
Texture2D assetTexture = null;
if (size == ImageSize.XXHDPI)
{
assetTexture = data.AssetXXHDPI;
}
if (size == ImageSize.XHDPI)
{
assetTexture = data.AssetXHDPI;
}
if (size == ImageSize.HDPI)
{
assetTexture = data.AssetHDPI;
}
if (size == ImageSize.MDPI)
{
assetTexture = data.AssetMDPI;
}
if (size == ImageSize.LDPI)
{
assetTexture = data.AssetLDPI;
}
var newAsset = (Texture2D)EditorGUI.ObjectField(
textureRect,
assetTexture,
typeof(Texture2D),
false);
// ---
bool updatePreviewTexture = (newId != data.Id || newType != data.Type || newAsset != data.Asset);
if (updatePreviewTexture)
{
Undo.RegisterCompleteObjectUndo(target, "Update icon data.");
data.Id = newId;
data.Type = newType;
data.Asset = newAsset;
if (size == ImageSize.XXHDPI)
{
data.AssetXXHDPI = newAsset;
}
if (size == ImageSize.XHDPI)
{
data.AssetXHDPI = newAsset;
}
if (size == ImageSize.HDPI)
{
data.AssetHDPI = newAsset;
}
if (size == ImageSize.MDPI)
{
data.AssetMDPI = newAsset;
}
if (size == ImageSize.LDPI)
{
data.AssetLDPI = newAsset;
}
data.previewTexture = data.GetPreviewTexture(updatePreviewTexture);
data.Clean();
data.Verify();
}
// TODO Allocates a lot of memory for some reason, cache.
if (data.Asset != null && !data.Verify())
{
EditorGUI.HelpBox(
errorBoxRect,
"Specified texture can't be used because: \n" + (errorMsgWidth > 145
? DrawableResourceData.GenerateErrorString(data.Errors)
: "...expand to see more..."),
MessageType.Error
);
if (data.Type == NotificationIconType.SmallIcon)
{
GUIStyle helpBoxMessageTextStyle = new GUIStyle(GUI.skin.label);
helpBoxMessageTextStyle.fontSize = 8;
helpBoxMessageTextStyle.wordWrap = true;
helpBoxMessageTextStyle.alignment = TextAnchor.MiddleCenter;
GUI.Box(previewTextureRect, "Preview not available. \n Make sure the texture is readable!", helpBoxMessageTextStyle);
}
}
else
{
if (data.previewTexture != null)
{
GUIStyle previewLabelTextStyle = new GUIStyle(GUI.skin.label);
previewLabelTextStyle.fontSize = 8;
previewLabelTextStyle.wordWrap = true;
previewLabelTextStyle.alignment = TextAnchor.UpperCenter;
EditorGUI.LabelField(previewTextureRect, "Preview", previewLabelTextStyle);
Rect previewTextureRectPadded = GetContentRect(previewTextureRect, 6f, 6f);
previewTextureRectPadded.y += 8;
data.previewTexture.alphaIsTransparency = false;
GUI.DrawTexture(previewTextureRectPadded, data.previewTexture);
}
}
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
pathName = Utility.GetCleanPath(pathName);
UnityEngine.Object o = ProtoTemplateMenuItem.CreateScript(pathName, resourceFile);
ProjectWindowUtil.ShowCreatedAsset(o);
}
public void Print(UnityEngine.Object m)
{
Debug.Log((m as IntVariable).value);
}
public void LogWarning(string message, UnityEngine.Object context = null)
{
ctx.LogImportWarning(message, context);
}
public void LogError(string message, UnityEngine.Object context = null)
{
// Note: if you get sent here by clicking on a ShaderGraph error message,
// this is a bug in the scripted importer system, not being able to link import error messages to the imported asset
ctx.LogImportError(message, context);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var importLog = new AssetImportErrorLog(ctx);
string path = ctx.assetPath;
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(),
assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
UnityEngine.Object mainObject = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
// build shaders
mainObject = BuildAllShaders(ctx, importLog, assetCollection, graph);
}
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
sgMetadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
List <GraphInputData> inputInspectorDataList = new List <GraphInputData>();
foreach (AbstractShaderProperty property in graph.properties)
{
// Don't write out data for non-exposed blackboard items
if (!property.isExposed)
{
continue;
}
// VTs are treated differently
if (property is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
inputInspectorDataList.Add(MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty));
}
else
{
inputInspectorDataList.Add(new GraphInputData()
{
referenceName = property.referenceName, propertyType = property.propertyType, isKeyword = false
});
}
}
foreach (ShaderKeyword keyword in graph.keywords)
{
// Don't write out data for non-exposed blackboard items
if (!keyword.isExposed)
{
continue;
}
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
inputInspectorDataList.Add(new GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
});
}
sgMetadata.categoryDatas = new List <MinimalCategoryData>();
foreach (CategoryData categoryData in graph.categories)
{
// Don't write out empty categories
if (categoryData.childCount == 0)
{
continue;
}
MinimalCategoryData mcd = new MinimalCategoryData()
{
categoryName = categoryData.name,
propertyDatas = new List <GraphInputData>()
};
foreach (var input in categoryData.Children)
{
GraphInputData propData;
// Only write out data for exposed blackboard items
if (input.isExposed == false)
{
continue;
}
// VTs are treated differently
if (input is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
propData = MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty);
inputInspectorDataList.RemoveAll(inputData => inputData.referenceName == propData.referenceName);
mcd.propertyDatas.Add(propData);
continue;
}
else if (input is ShaderKeyword keyword)
{
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
propData = new GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
};
}
else
{
var prop = input as AbstractShaderProperty;
propData = new GraphInputData()
{
referenceName = input.referenceName, propertyType = prop.propertyType, isKeyword = false
};
}
mcd.propertyDatas.Add(propData);
inputInspectorDataList.Remove(propData);
}
sgMetadata.categoryDatas.Add(mcd);
}
// Any uncategorized elements get tossed into an un-named category at the top as a fallback
if (inputInspectorDataList.Count > 0)
{
sgMetadata.categoryDatas.Insert(0, new MinimalCategoryData()
{
categoryName = "", propertyDatas = inputInspectorDataList
});
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
importLog.LogWarning($"Invalid dependency path: {assetPath}", mainObject);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderMessages(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(), assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
Shader shader = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
// build the shader text
// this will also add Target dependencies into the asset collection
var text = GetShaderText(path, out configuredTextures, assetCollection, graph);
#if UNITY_2021_1_OR_NEWER
// 2021.1 or later is guaranteed to have the new version of this function
shader = ShaderUtil.CreateShaderAsset(ctx, text, false);
#else
// earlier builds of Unity may or may not have it
// here we try to invoke the new version via reflection
var createShaderAssetMethod = typeof(ShaderUtil).GetMethod(
"CreateShaderAsset",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.ExactBinding,
null,
new Type[] { typeof(AssetImportContext), typeof(string), typeof(bool) },
null);
if (createShaderAssetMethod != null)
{
shader = createShaderAssetMethod.Invoke(null, new Object[] { ctx, text, false }) as Shader;
}
else
{
// method doesn't exist in this version of Unity, call old version
// this doesn't create dependencies properly, but is the best that we can do
shader = ShaderUtil.CreateShaderAsset(text, false);
}
#endif
ReportErrors(graph, shader, path);
EditorMaterialUtility.SetShaderDefaults(
shader,
configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
EditorMaterialUtility.SetShaderNonModifiableDefaults(
shader,
configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
}
UnityEngine.Object mainObject = shader;
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
sgMetadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
List <MinimalCategoryData.GraphInputData> inputInspectorDataList = new List <MinimalCategoryData.GraphInputData>();
foreach (AbstractShaderProperty property in graph.properties)
{
// Don't write out data for non-exposed blackboard items
if (!property.isExposed)
{
continue;
}
// VTs are treated differently
if (property is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
inputInspectorDataList.Add(MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty));
}
else
{
inputInspectorDataList.Add(new MinimalCategoryData.GraphInputData()
{
referenceName = property.referenceName, propertyType = property.propertyType, isKeyword = false
});
}
}
foreach (ShaderKeyword keyword in graph.keywords)
{
// Don't write out data for non-exposed blackboard items
if (!keyword.isExposed)
{
continue;
}
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
inputInspectorDataList.Add(new MinimalCategoryData.GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
});
}
sgMetadata.categoryDatas = new List <MinimalCategoryData>();
foreach (CategoryData categoryData in graph.categories)
{
// Don't write out empty categories
if (categoryData.childCount == 0)
{
continue;
}
MinimalCategoryData mcd = new MinimalCategoryData()
{
categoryName = categoryData.name,
propertyDatas = new List <MinimalCategoryData.GraphInputData>()
};
foreach (var input in categoryData.Children)
{
MinimalCategoryData.GraphInputData propData;
// Only write out data for exposed blackboard items
if (input.isExposed == false)
{
continue;
}
// VTs are treated differently
if (input is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
propData = MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty);
inputInspectorDataList.RemoveAll(inputData => inputData.referenceName == propData.referenceName);
mcd.propertyDatas.Add(propData);
continue;
}
else if (input is ShaderKeyword keyword)
{
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
propData = new MinimalCategoryData.GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
};
}
else
{
var prop = input as AbstractShaderProperty;
propData = new MinimalCategoryData.GraphInputData()
{
referenceName = input.referenceName, propertyType = prop.propertyType, isKeyword = false
};
}
mcd.propertyDatas.Add(propData);
inputInspectorDataList.Remove(propData);
}
sgMetadata.categoryDatas.Add(mcd);
}
// Any uncategorized elements get tossed into an un-named category at the top as a fallback
if (inputInspectorDataList.Count > 0)
{
sgMetadata.categoryDatas.Insert(0, new MinimalCategoryData()
{
categoryName = "", propertyDatas = inputInspectorDataList
});
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {assetPath}", mainObject);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
public bool SetPositionProperty(Vector3Int position, String name, UnityEngine.Object positionProperty)
{
return(SetPositionProperty(position, name, GridInformationType.UnityObject, positionProperty));
}
public void AddScript(UnityEngine.Object script)
{
Scripts.Add(script.name, script.ToString());
}
public static void Warn(string msg, UnityEngine.Object obj)
{
Debug.Log("<b>HandUI: </b>" + msg, obj);
}
public void LogException(Exception exception, UnityEngine.Object context)
{
Console.WriteLine("{0} - {1}", context, exception);
}
public void LogFormat(LogType logType, UnityEngine.Object context, string format, params object[] args)
{
var formatted = string.Format(format, args);
Console.WriteLine("{0}:{1} - {2}", logType, context, formatted);
}
// Unity Object Info
public static string GetScenePath(this UnityEngine.Object component)
{
return(GetScenePath(component as Component));
}
static bool ExposedReferenceProperty(FieldInfo p_fieldInfo, Object p_object, GUIContent p_name, IReferencable p_reference)
{
if (!IsExposedReferenceProperty(p_fieldInfo))
{
return(false);
}
IExposedPropertyTable propertyTable = DashEditorCore.EditorConfig.editingController;
var exposedReference = p_fieldInfo.GetValue(p_object);
PropertyName exposedName = (PropertyName)exposedReference.GetType().GetField("exposedName").GetValue(exposedReference);
bool isDefault = PropertyName.IsNullOrEmpty(exposedName);
GUILayout.BeginHorizontal();
GUILayout.Label(p_name, GUILayout.Width(160));
HandleReferencing(p_reference, p_fieldInfo);
EditorGUI.BeginChangeCheck();
UnityEngine.Object exposedValue = (UnityEngine.Object)exposedReference.GetType().GetMethod("Resolve")
.Invoke(exposedReference, new object[] { propertyTable });
var newValue = EditorGUILayout.ObjectField(exposedValue, p_fieldInfo.FieldType.GetGenericArguments()[0], true);
GUILayout.EndHorizontal();
if (EditorGUI.EndChangeCheck())
{
if (propertyTable != null)
{
Undo.RegisterCompleteObjectUndo(propertyTable as UnityEngine.Object, "Set Exposed Property");
}
if (!isDefault)
{
if (newValue == null)
{
propertyTable.ClearReferenceValue(exposedName);
exposedReference.GetType().GetField("exposedName").SetValue(exposedReference, null);
p_fieldInfo.SetValue(p_object, exposedReference);
}
else
{
propertyTable.SetReferenceValue(exposedName, newValue);
}
}
else
{
if (newValue != null)
{
PropertyName newExposedName = new PropertyName(GUID.Generate().ToString());
exposedReference.GetType().GetField("exposedName")
.SetValue(exposedReference, newExposedName);
propertyTable.SetReferenceValue(newExposedName, newValue);
p_fieldInfo.SetValue(p_object, exposedReference);
}
}
return(true);
}
return(false);
}
// placeholder, this should not be called in runtime
public static string GetAssetPath(UnityEngine.Object rsrc)
{
return(rsrc.name);
}
static UnityEngine.Object ObjectField(UnityEngine.Object obj, System.Type type)
{
return(helper.ObjectField(obj, type));
}
private static void CollectProxy(List <LinkResolver> temporaryResolvers, Type proxyType) //AnimTrackProxy
{
GameObject GetPassthroughGameObject(UnityEngine.Object obj)
{
if (obj is Component asComponent)
{
return(asComponent.gameObject);
}
else if (obj is GameObject asGO)
{
return(asGO);
}
throw new NotSupportedException($"Unsupported passthrough type {obj.GetType()}.");
}
var proxy = Activator.CreateInstance(proxyType) as CrossSceneReferenceProxy;
// Search all open scenes for GameObject components matching the proxy's relevant component type
foreach (Component relevantComponent in UnityEngine.Object.FindObjectsOfType(proxy.RelevantComponentType, true))
{
// Generate a context for the proxy to effectively operate on targets & passthroughs.
UnityEngine.Object context = proxy.AcquireContext(relevantComponent);
// Iterate through all the proxy-type members contained within the relevant component instance.
UnityEngine.Object[] proxyTargets = proxy.GetTargets(context);
// However, if there are no valid targets, the context is useless.
// No further logic is necessary for this iteration. Let's interrupt & dispose.
if (proxyTargets == null || proxyTargets.Length == 0)
{
proxy.ReleaseContext(context);
continue;
}
for (int i = 0; i < proxyTargets.Length; ++i)
{
var target = proxyTargets[i] as object;
// Obtain the component at the other end of the proxy.
UnityEngine.Object passthrough = proxy.GetPassthrough(ref target, context);
if (passthrough == null)
{
continue; // No proxying to be done. Skip iteration.
}
// By now, we guarantee a GameObject component with a valid proxy endpoint.
// Create a resolver to connect both proxy endpoints.
CrossSceneReferenceResolver resolver = GetOrCreateResolver(relevantComponent);
// Set up a CrossSceneReferenceLocator and get the GUID which has been assigned to the passthrough component.
CrossSceneReferenceLocator loc = GetOrCreateLocator(GetPassthroughGameObject(passthrough));
int locGuidIdx = loc.Passthroughs.FindIndex(x => x == passthrough);
if (locGuidIdx == -1)
{
// Only generate new GUID for unique entries.
loc.ComponentGUIDS.Add(GUID.Generate().ToString());
loc.Passthroughs.Add(passthrough);
locGuidIdx = loc.ComponentGUIDS.Count - 1;
}
// Mark relevant component's scene for saving to serialize the resolver on the Unity scene.
Scene scene = relevantComponent.gameObject.scene;
EditorSceneManager.MarkSceneDirty(scene);
// Store the data required so that the link can be restored at runtime
CrossSceneReferenceSetupData data = new CrossSceneReferenceSetupData()
{
ClassHash = CodeGenerator.ClassHashFromType(proxyType),
RouteHash = proxy.GenerateRouteHash(passthrough, context),
Target = target as UnityEngine.Object,
GUID = loc.ComponentGUIDS[locGuidIdx],
Context = context
};
resolver.AddResolverData(data);
// More immediate way to restore the links once save is complete
temporaryResolvers.Add(new TemporaryProxyLinkResolver() // REVIEW: Consider not overloading Temp Link Resolver. Make specific classes for use case.
{
ProxyType = proxyType,
Target = target,
Value = passthrough,
Context = context,
Route = data.RouteHash
});
// Set to null during Scene save, otherwise Unity will complain about cross scene refs
proxy.Set(data.RouteHash, target, null, context);
}
}
}
public void LogFormat(LogType logType, UnityEngine.Object context, String format, params Object[] args)
{
_log.Write(GetPrefix(logType), 0, format, args);
_native.LogFormat(logType, context, format, args);
}
/// <summary>
/// Loads the instance.
/// </summary>
/// <returns>The instance.</returns>
/// <param name="_path">_path.</param>
public UnityEngine.Object LoadInstance(string _path)
{
UnityEngine.Object _obj = Load(_path);
return(Instantiate(_obj));
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderMessages(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(), assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
Shader shader = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
// build the shader text
// this will also add Target dependencies into the asset collection
var text = GetShaderText(path, out configuredTextures, assetCollection, graph);
#if UNITY_2021_1_OR_NEWER
// 2021.1 or later is guaranteed to have the new version of this function
shader = ShaderUtil.CreateShaderAsset(ctx, text, false);
#else
// earlier builds of Unity may or may not have it
// here we try to invoke the new version via reflection
var createShaderAssetMethod = typeof(ShaderUtil).GetMethod(
"CreateShaderAsset",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.ExactBinding,
null,
new Type[] { typeof(AssetImportContext), typeof(string), typeof(bool) },
null);
if (createShaderAssetMethod != null)
{
shader = createShaderAssetMethod.Invoke(null, new Object[] { ctx, text, false }) as Shader;
}
else
{
// method doesn't exist in this version of Unity, call old version
// this doesn't create dependencies properly, but is the best that we can do
shader = ShaderUtil.CreateShaderAsset(text, false);
}
#endif
if (graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
EditorMaterialUtility.SetShaderDefaults(
shader,
configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
EditorMaterialUtility.SetShaderNonModifiableDefaults(
shader,
configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
}
UnityEngine.Object mainObject = shader;
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
sgMetadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {assetPath}", mainObject);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
public Parameter(UnityEngine.Object obj, String field)
{
this.obj = obj;
this.field = field;
}
