/// <summary> /// Loads the graph asset model and the persisted state associated with the asset. /// </summary> /// <param name="assetModel">The graph asset model to load.</param> /// <param name="boundObject">The GameObject to which the graph is bound, if any.</param> public void LoadGraphAsset(IGraphAssetModel assetModel, GameObject boundObject) { ResetStateCaches(); if (assetModel != null) { if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(assetModel as Object, out var guid, out long fileId)) { guid = (assetModel as Object)?.GetInstanceID().ToString() ?? "0"; fileId = 0; } PersistedState.SetAssetKey(guid + "/" + fileId); } else { PersistedState.SetAssetKey(""); } using (var windowStateUpdater = WindowState.UpdateScope) { windowStateUpdater.LoadGraphAsset(assetModel, boundObject); } using (var graphViewStateUpdater = GraphViewState.UpdateScope) { graphViewStateUpdater.LoadGraphAsset(assetModel); } }
public void TestWithGraphAssets(IGraphAssetModel graphAssetModel, bool result) { var filter = new SearcherFilter(SearcherContext.Graph).WithMacros(); var data = new GraphAssetSearcherItemData(graphAssetModel); Assert.AreEqual(result, filter.ApplyFilters(data)); }
public static void SetAssetDirty(this IGraphAssetModel graphAssetModel) { if (graphAssetModel as Object) { EditorUtility.SetDirty((Object)graphAssetModel); } }
/// <summary> /// Loads a graph asset from file. /// </summary> /// <param name="path">The path of the file.</param> /// <param name="localFileId">The id of the asset in the file. If 0, the first asset of type <see cref="GraphAssetModel"/> will be loaded.</param> /// <returns>The loaded asset, or null if it was not found or if the asset found is not an <see cref="IGraphAssetModel"/>.</returns> public static IGraphAssetModel Load(string path, long localFileId) { IGraphAssetModel assetModel = null; if (localFileId != 0L) { var assets = AssetDatabase.LoadAllAssetsAtPath(path); foreach (var a in assets) { if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(a, out _, out long localId)) { continue; } if (localId == localFileId) { return(a as IGraphAssetModel); } } } else { assetModel = (IGraphAssetModel)AssetDatabase.LoadAssetAtPath(path, typeof(GraphAssetModel)); } return(assetModel); }
public override void SetUp() { base.SetUp(); m_Asset1 = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateGraphAsset(CreatedGraphType, "Test1", "Assets/test1.asset"); Window.CommandDispatcher.State.LoadGraphAsset(m_Asset1, null); }
/// <summary> /// Initializes a new instance of the <see cref="LoadGraphAssetCommand"/> class. /// </summary> /// <param name="assetModel">The asset model to load.</param> /// <param name="boundObject">The game object to which the graph should be bound.</param> /// <param name="loadStrategy">The type of loading and how it should affect the stack of loaded assets.</param> public LoadGraphAssetCommand(IGraphAssetModel assetModel, GameObject boundObject = null, LoadStrategies loadStrategy = LoadStrategies.Replace) { AssetPath = null; Asset = assetModel; BoundObject = boundObject; LoadStrategy = loadStrategy; TruncateHistoryIndex = -1; }
public static TypeHandle GenerateTypeHandle(this IGraphAssetModel asset, ITypeHandleSerializer serializer) { if (asset is VSGraphAssetModel vsGraphAssetModel) { return(serializer.GenerateTypeHandle(vsGraphAssetModel.GraphModel as VSGraphModel)); } return(TypeHandle.Unknown); }
/// <summary> /// Loads a graph asset in the window. /// </summary> /// <param name="assetModel">The graph asset to load.</param> /// <param name="boundObject">The GameObject to which the asset is bound, if any.</param> public void LoadGraphAsset(IGraphAssetModel assetModel, GameObject boundObject) { if (!string.IsNullOrEmpty(m_State.m_CurrentGraph.GetGraphAssetModelPath())) { m_State.m_LastOpenedGraph = m_State.m_CurrentGraph; } m_State.m_CurrentGraph = new OpenedGraph(assetModel, boundObject); m_State.m_BlackboardGraphModel = null; m_State.SetUpdateType(UpdateType.Complete); }
/// <summary> /// Initializes a new instance of the <see cref="LoadGraphAssetCommand"/> class. /// </summary> /// <param name="assetPath">The path of the asset to load.</param> /// <param name="assetLocalId">The subasset file id. If 0, the first GraphAssetModel found in the file will be loaded.</param> /// <param name="pluginRepository">The plugin repository.</param> /// <param name="boundObject">The game object to which the graph should be bound.</param> /// <param name="loadStrategy">The type of loading and how it should affect the stack of loaded assets.</param> /// <param name="truncateHistoryIndex">Truncate the stack of loaded assets at this index.</param> public LoadGraphAssetCommand(string assetPath, long assetLocalId, PluginRepository pluginRepository, GameObject boundObject = null, LoadStrategies loadStrategy = LoadStrategies.Replace, int truncateHistoryIndex = -1) { Asset = null; AssetPath = assetPath; BoundObject = boundObject; LoadStrategy = loadStrategy; FileId = assetLocalId; PluginRepository = pluginRepository; TruncateHistoryIndex = truncateHistoryIndex; }
public void SetCurrentSelection(IGraphAssetModel graphAssetModel, OpenMode mode, GameObject boundObject = null) { var windows = (GraphViewEditorWindow[])Resources.FindObjectsOfTypeAll(typeof(GraphViewEditorWindow)); // Only the last focused editor should try to answer a change to the current selection. if (s_LastFocusedEditor != GetInstanceID() && windows.Length > 1) { return; } var currentOpenedGraph = CommandDispatcher?.State?.WindowState.CurrentGraph ?? default; // don't load if same graph and same bound object if (CommandDispatcher?.State?.WindowState.AssetModel != null && graphAssetModel == currentOpenedGraph.GetGraphAssetModel() && currentOpenedGraph.BoundObject == boundObject) { return; } var graphAssetFilePath = graphAssetModel.GetPath(); var fileId = graphAssetModel.GetFileId(); // If there is not graph asset, unload the current one. if (string.IsNullOrWhiteSpace(graphAssetFilePath) || fileId == 0) { return; } // Load this graph asset. CommandDispatcher?.Dispatch(new LoadGraphAssetCommand(graphAssetFilePath, fileId, PluginRepository, boundObject)); if (GraphView?.GraphModel?.AssetModel != null) { UpdateDirtyState(GraphView.GraphModel.AssetModel.Dirty); } if (mode != OpenMode.OpenAndFocus) { return; } // Check if an existing window already has this asset, if yes give it the focus. foreach (var window in windows) { if (window.CommandDispatcher.State.WindowState.AssetModel == graphAssetModel) { window.Focus(); return; } } }
/// <summary> /// Initializes a new instance of the <see cref="OpenedGraph" /> class. /// </summary> /// <param name="graphAssetModel">The graph asset model.</param> /// <param name="boundObject">The GameObject bound to the graph.</param> public OpenedGraph(IGraphAssetModel graphAssetModel, GameObject boundObject) { if (graphAssetModel == null || !AssetDatabase.TryGetGUIDAndLocalFileIdentifier(graphAssetModel as Object, out m_AssetGUID, out m_AssetLocalId)) { m_AssetGUID = ""; m_AssetLocalId = 0L; } m_GraphAssetModel = graphAssetModel; m_GraphAssetObjectInstanceID = (graphAssetModel as Object)?.GetInstanceID() ?? 0; m_BoundObject = boundObject; }
static void AddScriptingGraphToObject(IGraphAssetModel graphAssetModel, GameObject target) { if (target.GetComponent <ConvertToEntity>() == null) { target.AddComponent <ConvertToEntity>(); } ScriptingGraphAuthoring authoring = target.GetComponent <ScriptingGraphAuthoring>(); if (authoring == null) { authoring = target.AddComponent <ScriptingGraphAuthoring>(); } authoring.ScriptingGraph = ((DotsStencil)(graphAssetModel as GraphAssetModel)?.GraphModel.Stencil)?.CompiledScriptingGraphAsset; }
void EnsureGraphAssetModelIsLoaded() { // GUIDToAssetPath cannot be done in ISerializationCallbackReceiver.OnAfterDeserialize so we do it here. var doReload = false; if (m_GraphAssetModel == null) { doReload = true; } else if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(m_GraphAssetModel as Object, out var assetGuid, out long localId)) { doReload = assetGuid != m_AssetGUID || localId != m_AssetLocalId; } if (doReload) { // Try to load object from its GUID. Will fail if it is a memory based asset or if the asset was deleted. if (!string.IsNullOrEmpty(m_AssetGUID)) { var graphAssetModelPath = AssetDatabase.GUIDToAssetPath(m_AssetGUID); m_GraphAssetModel = Load(graphAssetModelPath, m_AssetLocalId); } // If it failed, try to retrieve object from its instance id (memory based asset). if (m_GraphAssetModel == null && m_GraphAssetObjectInstanceID != 0) { m_GraphAssetModel = EditorUtility.InstanceIDToObject(m_GraphAssetObjectInstanceID) as IGraphAssetModel; } if (m_GraphAssetModel == null) { m_AssetGUID = null; m_AssetLocalId = 0; m_GraphAssetObjectInstanceID = 0; } else { AssetDatabase.TryGetGUIDAndLocalFileIdentifier(m_GraphAssetModel as Object, out m_AssetGUID, out m_AssetLocalId); m_GraphAssetObjectInstanceID = (m_GraphAssetModel as Object)?.GetInstanceID() ?? 0; } } }
public override void SetUp() { base.SetUp(); GraphViewSettings.UserSettings.EnableSnapToBorders = false; GraphViewSettings.UserSettings.EnableSnapToPort = false; m_AssetModel = GraphAssetCreationHelpers <TestAssetModel> .CreateGraphAsset(typeof(TestStencil), "TestFile", k_FilePath); CommandDispatcher.Dispatch(new LoadGraphAssetCommand(m_AssetModel)); m_NodeModel = CreateNode("Movable element", k_NodePos, 0, 1); // Add the minimap. var miniMap = new MiniMap(); miniMap.style.left = k_MinimapRect.x; miniMap.style.top = k_MinimapRect.y; miniMap.style.width = k_MinimapRect.width; miniMap.style.height = k_MinimapRect.height; graphView.Add(miniMap); }
public void SetUp(CommandDispatcher commandDispatcher, IGraphAssetModel assetModel, IGraphTemplate template) { m_CommandDispatcher = commandDispatcher; m_Template = template; m_AssetModel = assetModel; }
/// <summary> /// Gets the file id of af the graph asset model. /// </summary> /// <param name="self">The graph asset model.</param> /// <returns>The path of the graph asset model.</returns> public static long GetFileId(this IGraphAssetModel self) { var obj = self as Object; return(AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out var _, out long fileId) ? fileId : 0); }
protected override bool CanHandleAssetType(IGraphAssetModel asset) { return(asset is ContextSampleAsset); }
public void SetUp() { m_Asset1 = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateInMemoryGraphAsset(typeof(ClassStencil), "Test1"); }
public SearcherFilter WithGraphAsset(IGraphAssetModel assetModel) { this.RegisterGraphAsset(data => data.GraphAssetModel == assetModel); return(this); }
public static ITypeMetadata GetMetadata(this IGraphAssetModel asset, Stencil stencil) { return(asset.GenerateTypeHandle(stencil).GetMetadata(stencil)); }
public GraphAssetSearcherItemData(IGraphAssetModel graphAssetModel) { GraphAssetModel = graphAssetModel; }
public static TypeHandle GenerateTypeHandle(this IGraphAssetModel asset, Stencil stencil) { return(asset.GenerateTypeHandle(stencil.GraphContext.TypeHandleSerializer)); }
/// <inheritdoc /> public RecipeBlackboardGraphModel(IGraphAssetModel graphAssetModel) : base(graphAssetModel) { }
/// <inheritdoc /> public VerticalBlackboardGraphModel(IGraphAssetModel graphAssetModel) : base(graphAssetModel) { }
/// <inheritdoc /> public override IBlackboardGraphModel CreateBlackboardGraphModel(IGraphAssetModel graphAssetModel) { return(new BlackboardGraphModel(graphAssetModel)); }
public virtual bool GetGraphAndObjectFromSelection(CommandDispatcher dispatcher, Object selectedObject, out IGraphAssetModel graphAssetModel, out GameObject boundObject) { graphAssetModel = null; boundObject = null; if (selectedObject is IGraphAssetModel selectedObjectAsGraph) { // don't change the current object if it's the same graph if (selectedObjectAsGraph == dispatcher.State?.WindowState.GraphModel?.AssetModel) { var currentOpenedGraph = dispatcher.State.WindowState.CurrentGraph; graphAssetModel = currentOpenedGraph.GetGraphAssetModel(); boundObject = currentOpenedGraph.BoundObject; return(true); } } return(false); }
public bool IsSameAsset(IGraphAssetModel otherGraphAssetModel) { return(GetHashCode() == otherGraphAssetModel?.GetHashCode()); }
/// <inheritdoc /> protected override bool CanHandleAssetType(IGraphAssetModel asset) { return(asset is VerticalGraphAssetModel); }
protected override bool CanHandleAssetType(IGraphAssetModel asset) { return(true); }
public void SetUp() { m_GraphAsset = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateInMemoryGraphAsset(typeof(ClassStencil), "Test"); m_GraphAsset.CreateGraph("Graph"); }