public static ComponentQueryDeclarationModel CreateComponentQuery(this VSGraphModel graphModel, string queryName)
{
var field = VariableDeclarationModel.CreateDeclarationNoUndoRecord <ComponentQueryDeclarationModel>(queryName,
typeof(EntityQuery).GenerateTypeHandle(graphModel.Stencil),
true,
graphModel,
VariableType.ComponentQueryField,
ModifierFlags.ReadOnly,
null,
VariableFlags.None);
graphModel.VariableDeclarations.Add(field);
return(field);
}
public void SetNameFromUserNameTest(string userInput, string expectedName, string expectedTitle)
{
VSGraphAssetModel graphAssetModel = (VSGraphAssetModel)GraphAssetModel.Create("test", "", typeof(VSGraphAssetModel));
VSGraphModel graph = graphAssetModel.CreateVSGraph <ClassStencil>("test");
var method = graph.CreateFunction("method", Vector2.left * 200);
method.CreateFunctionVariableDeclaration("bar", typeof(int).GenerateTypeHandle(graph.Stencil));
var variable = method.CreateFunctionVariableDeclaration("temp", typeof(int).GenerateTypeHandle(graph.Stencil));
variable.SetNameFromUserName(userInput);
Assert.That(variable.VariableName, Is.EqualTo(expectedName));
Assert.That(variable.Title, Is.EqualTo(expectedTitle));
}
static State DotsCreateGetSetVariableNodes(State prevState, DotsCreateGetSetVariableNodesAction action)
{
VSGraphModel vsGraphModel = ((VSGraphModel)prevState.CurrentGraphModel);
foreach (var tuple in action.VariablesToCreate)
{
vsGraphModel.CreateNode <SetVariableNodeModel>(tuple.Item1.Title, tuple.Item2, SpawnFlags.Default, v =>
{
v.DeclarationModel = tuple.Item1;
v.IsGetter = action.CreateGetters;
});
}
return(prevState);
}
static State UpdateStickyNoteTextSize(State previousState, UpdateStickyNoteTextSizeAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
Undo.RegisterCompleteObjectUndo((Object)previousState.AssetModel, "Change Sticky Note Text Size");
foreach (var stickyNoteModel in action.StickyNoteModels.OfType <StickyNoteModel>())
{
stickyNoteModel.UpdateTextSize(action.TextSize);
graphModel.LastChanges.ChangedElements.Add(stickyNoteModel);
}
previousState.MarkForUpdate(UpdateFlags.GraphTopology);
return(previousState);
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
public void Test_FunctionVariableDeclarationsIsSerializedInGraphAsset()
{
VSGraphAssetModel graphAssetModel = (VSGraphAssetModel)GraphAssetModel.Create("test", "Assets/MyGraphTest.asset", typeof(VSGraphAssetModel));
VSGraphModel graph = graphAssetModel.CreateVSGraph <ClassStencil>("test");
FunctionModel method = graph.CreateFunction("TestFunction", Vector2.zero);
VariableDeclarationModel declaration = method.CreateFunctionVariableDeclaration("var", typeof(int).GenerateTypeHandle(graph.Stencil));
string nodeModelPath = AssetDatabase.GetAssetPath(declaration.InitializationModel.SerializableAsset);
string graphAssetModelPath = AssetDatabase.GetAssetPath(graphAssetModel);
Assert.That(nodeModelPath, Is.EqualTo(graphAssetModelPath));
AssetDatabase.DeleteAsset(graphAssetModelPath);
}
public virtual Microsoft.CodeAnalysis.SyntaxTree OnTranslate(VSGraphModel graphModel, AssemblyType assemblyType, CompilationOptions compilationOptions, ref CompilationResult compilationResult)
{
const string windowsLineEndings = "\r\n";
const string unixLineEndings = "\n";
Microsoft.CodeAnalysis.SyntaxTree syntaxTree = Translate(graphModel, compilationOptions); // we will measure plugins time later
string preferredLineEndings;
LineEndingsMode lineEndingsForNewScripts = EditorSettings.lineEndingsForNewScripts;
switch (lineEndingsForNewScripts)
{
case LineEndingsMode.OSNative:
preferredLineEndings = Application.platform == RuntimePlatform.WindowsEditor ? windowsLineEndings : unixLineEndings;
break;
case LineEndingsMode.Unix:
preferredLineEndings = unixLineEndings;
break;
case LineEndingsMode.Windows:
preferredLineEndings = windowsLineEndings;
break;
default:
preferredLineEndings = unixLineEndings;
break;
}
var adHocWorkspace = new AdhocWorkspace();
var options = adHocWorkspace.Options
.WithChangedOption(CSharpFormattingOptions.NewLineForMembersInObjectInit, true)
.WithChangedOption(CSharpFormattingOptions.WrappingPreserveSingleLine, false)
.WithChangedOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine, false)
.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers, true)
.WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, preferredLineEndings);
compilationResult.sourceCode[(int)SourceCodePhases.Initial] = syntaxTree.GetText().ToString();
var formattedTree = Formatter.Format(syntaxTree.GetCompilationUnitRoot(), adHocWorkspace, options);
formattedTree = new VisualScriptingCSharpFormatter().Visit(formattedTree);
string codeText = formattedTree.GetText().ToString();
compilationResult.sourceCode[(int)SourceCodePhases.Final] = codeText;
return(syntaxTree);
}
static State RenameElement(State previousState, RenameElementAction action)
{
var graphModel = (VSGraphModel)previousState.CurrentGraphModel;
if (string.IsNullOrWhiteSpace(action.Name))
{
return(previousState);
}
Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Rename");
action.RenamableModel.Rename(action.Name);
EditorUtility.SetDirty((Object)graphModel.AssetModel);
IGraphChangeList graphChangeList = previousState.CurrentGraphModel.LastChanges;
VSGraphModel vsGraphModel = (VSGraphModel)previousState.CurrentGraphModel;
if (action.RenamableModel is VariableDeclarationModel variableDeclarationModel)
{
graphChangeList.BlackBoardChanged = true;
// update usage names
graphChangeList.ChangedElements.AddRange(vsGraphModel.FindUsages <VariableNodeModel>(variableDeclarationModel));
}
else if (action.RenamableModel is IVariableModel variableModel)
{
graphChangeList.BlackBoardChanged = true;
variableDeclarationModel = variableModel.DeclarationModel as VariableDeclarationModel;
graphChangeList.ChangedElements.Add(variableDeclarationModel);
graphChangeList.ChangedElements.AddRange(vsGraphModel.FindUsages <VariableNodeModel>(variableDeclarationModel));
}
else if (action.RenamableModel is IEdgePortalModel edgePortalModel)
{
variableDeclarationModel = edgePortalModel.DeclarationModel as VariableDeclarationModel;
graphChangeList.ChangedElements.Add(variableDeclarationModel);
graphChangeList.ChangedElements.AddRange(vsGraphModel.FindUsages <EdgePortalModel>(variableDeclarationModel));
}
else
{
graphChangeList.ChangedElements.Add(action.RenamableModel as IGraphElementModel);
}
previousState.MarkForUpdate(UpdateFlags.RequestCompilation | UpdateFlags.RequestRebuild);
return(previousState);
}
static void CreateItemizedNode(State state, VSGraphModel graphModel, ref IPortModel outputPortModel)
{
ItemizeOptions currentItemizeOptions = state.Preferences.CurrentItemizeOptions;
// automatically itemize, i.e. duplicate variables as they get connected
if (outputPortModel.Connected && currentItemizeOptions != ItemizeOptions.Nothing)
{
var nodeToConnect = outputPortModel.NodeModel;
var offset = Vector2.up * k_NodeOffset;
if (currentItemizeOptions.HasFlag(ItemizeOptions.Constants) &&
nodeToConnect is ConstantNodeModel constantModel)
{
string newName = string.IsNullOrEmpty(constantModel.Title)
? "Temporary"
: constantModel.Title + "Copy";
nodeToConnect = graphModel.CreateConstantNode(
newName,
constantModel.Type.GenerateTypeHandle(graphModel.Stencil),
constantModel.Position + offset
);
((ConstantNodeModel)nodeToConnect).ObjectValue = constantModel.ObjectValue;
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.Variables) &&
nodeToConnect is VariableNodeModel variableModel)
{
nodeToConnect = graphModel.CreateVariableNode(variableModel.DeclarationModel,
variableModel.Position + offset);
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.Variables) &&
nodeToConnect is ThisNodeModel thisModel)
{
nodeToConnect = graphModel.CreateNode <ThisNodeModel>("this", thisModel.Position + offset);
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.SystemConstants) &&
nodeToConnect is SystemConstantNodeModel sysConstModel)
{
Action <SystemConstantNodeModel> preDefineSetup = m =>
{
m.ReturnType = sysConstModel.ReturnType;
m.DeclaringType = sysConstModel.DeclaringType;
m.Identifier = sysConstModel.Identifier;
};
nodeToConnect = graphModel.CreateNode(sysConstModel.Title, sysConstModel.Position + offset, SpawnFlags.Default, preDefineSetup);
}
outputPortModel = nodeToConnect.OutputsById[outputPortModel.UniqueId];
}
}
public void VisitGraph(VSGraphModel vsGraphModel)
{
HashSet <IStackModel> visitedStacks = new HashSet <IStackModel>();
HashSet <INodeModel> visitedNodes = new HashSet <INodeModel>();
foreach (var entryPoint in vsGraphModel.Stencil.GetEntryPoints(vsGraphModel))
{
if (entryPoint is IStackModel entryStack)
{
VisitStack(entryStack, visitedStacks, visitedNodes);
}
else
{
VisitNode(entryPoint, visitedNodes);
}
}
// floating stacks
foreach (var stack in vsGraphModel.StackModels)
{
if (visitedStacks.Contains(stack))
{
continue;
}
VisitStack(stack, visitedStacks, visitedNodes);
}
// floating nodes
foreach (var node in vsGraphModel.NodeModels)
{
if (node == null || node is IStackModel || visitedNodes.Contains(node))
{
continue;
}
VisitNode(node, visitedNodes);
}
foreach (var variableDeclaration in vsGraphModel.GraphVariableModels)
{
VisitVariableDeclaration(variableDeclaration);
}
foreach (var edgeModel in vsGraphModel.EdgeModels)
{
VisitEdge(edgeModel);
}
}
public override void OnCompilationSucceeded(VSGraphModel graphModel, CompilationResult results)
{
var hash = ((DotsTranslator.DotsCompilationResult)results).GraphDefinition.ComputeHash();
if (hash == CompiledScriptingGraphAsset.HashCode)
{
return;
}
CompiledScriptingGraphAsset.HashCode = hash;
if (!EditorApplication.isPlaying)
{
return;
}
ScriptingGraphRuntime.LastVersion++;
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Move Stacked Node(s)");
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
public void Check(VSGraphModel macroGraphModel, IReadOnlyList <IPortModel> macroRefPorts, ModifierFlags modifierFlags)
{
Assert.That(macroRefPorts.Count, Is.EqualTo(macroGraphModel.VariableDeclarations.Count(v => v.Modifiers == modifierFlags)));
Assert.That(macroRefPorts.Count, Is.EqualTo(Count));
for (int i = 0; i < Count; i++)
{
if (m_Ports[i] == null)
{
Assert.That(macroRefPorts[i].Connected, Is.False);
}
else
{
Assert.That(macroRefPorts[i], Is.ConnectedTo(m_Ports[i]));
}
}
}
static State SplitStack(State previousState, SplitStackAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Move stacked nodes");
if (action.SplitIndex > 0 && action.SplitIndex < action.StackModel.NodeModels.Count())
{
// Get the list of nodes to move to another stack.
var nodeModels = action.StackModel.NodeModels.Skip(action.SplitIndex).ToList();
if (nodeModels.Any())
{
// Get old stack (stack A)
var stackA = action.StackModel;
// Create new stack (stack B).
var stackB = graphModel.CreateStack(((NodeModel)stackA).Title + "_split", stackA.Position + Vector2.up * 300);
// Move the list of nodes to this new stack.
stackB.MoveStackedNodes(nodeModels, 0);
// if the stack had a condition node or anything providing the actual port models, we need to move
// the nodes BEFORE fetching the port models, as stack.portModels will actually return the condition
// port models
var stackAOutputPortModel = stackA.OutputPorts.First();
var stackBInputPortModel = stackB.InputPorts.First();
var stackBOutputPortModel = stackB.OutputPorts.First();
// Connect the edges that were connected to the old stack to the new one.
var previousEdgeConnections = graphModel.GetEdgesConnections(stackAOutputPortModel).ToList();
foreach (var edge in previousEdgeConnections)
{
graphModel.CreateEdge(edge.InputPortModel, stackBOutputPortModel);
graphModel.DeleteEdge(edge);
}
// Connect the new stack with the old one.
IEdgeModel newEdge = graphModel.CreateEdge(stackBInputPortModel, stackAOutputPortModel);
graphModel.LastChanges.ChangedElements.Add(stackA);
graphModel.LastChanges.ModelsToAutoAlign.Add(newEdge);
}
}
return(previousState);
}
static State CreateVariableNodes(State previousState, CreateVariableNodesAction action)
{
if (action.VariablesToCreate.Count > 0)
{
if (action.ConnectAfterCreation != null)
{
// Delete previous connections
if (action.EdgeModelsToDelete.Any())
{
((VSGraphModel)previousState.CurrentGraphModel).DeleteEdges(action.EdgeModelsToDelete);
}
}
bool needToGroup = action.GroupModel != null;
List <INodeModel> nodesToGroup = needToGroup ? new List <INodeModel>(action.VariablesToCreate.Count) : null;
foreach (Tuple <IVariableDeclarationModel, Vector2> tuple in action.VariablesToCreate)
{
VSGraphModel vsGraphModel = ((VSGraphModel)previousState.CurrentGraphModel);
IVariableModel newVariable = vsGraphModel.CreateVariableNode(tuple.Item1, tuple.Item2);
if (action.ConnectAfterCreation != null)
{
var newEdge = ((VSGraphModel)previousState.CurrentGraphModel).CreateEdge(action.ConnectAfterCreation, newVariable.OutputPort);
if (action.AutoAlign)
{
vsGraphModel.LastChanges.ModelsToAutoAlign.Add(newEdge);
}
}
if (needToGroup)
{
nodesToGroup.Add(newVariable);
}
}
if (needToGroup)
{
GroupNodeModel.Ungroup(nodesToGroup);
((GroupNodeModel)action.GroupModel).AddNodes(nodesToGroup);
}
}
return(previousState);
}
public virtual void RemoveStackedNode(INodeModel nodeModel, EdgeBehaviourOnRemove edgeBehaviour = EdgeBehaviourOnRemove.Ignore)
{
((NodeModel)nodeModel).ParentStackModel = null;
int index = m_StackedNodeModels.IndexOf(nodeModel);
if (edgeBehaviour == EdgeBehaviourOnRemove.Transfer && index == m_StackedNodeModels.Count - 1 && ModelDelegatesOutputs(nodeModel))
{
TransferConnections(GraphModel, OutputPorts, m_OutputPorts);
}
m_StackedNodeModels.RemoveAt(index);
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
vsGraphModel.UnregisterNodeGuid(nodeModel.Guid);
vsGraphModel.LastChanges.DeletedElements++;
vsGraphModel.LastChanges.ChangedElements.Add(this);
}
static void CreateUpdateAndLogEntity(VSGraphModel graphModel, IVariableModel variable)
{
// update entities
var update = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(update.InstancePort, variable.OutputPort);
// Create entity from update
var entity = graphModel.CreateVariableNode(
update.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)),
Vector2.zero);
// Log the entity
var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
graphModel.CreateEdge(log.GetParameterPorts().First(), entity.OutputPort);
}
static State CreateLogNode(State previousState, CreateLogNodeAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
var stackModel = (StackBaseModel)action.StackModel;
var functionNode = stackModel.CreateStackedNode <LogNodeModel>(LogNodeModel.NodeTitle);
functionNode.LogType = action.LogType;
IConstantNodeModel constantNode = graphModel.CreateConstantNode(
"",
typeof(string).GenerateTypeHandle(graphModel.Stencil),
functionNode.Position - k_StackedTestNodesTokenOffset);
((ConstantNodeModel <string>)constantNode).value = $"{graphModel.NodeModels.Count}";
graphModel.CreateEdge(functionNode.InputPort, constantNode.OutputPort);
return(previousState);
}
public void OnCompilationDone(VSGraphModel vsGraphModel, CompilationOptions options, CompilationResult results)
{
if (!this)
{
// Should not happen, but it did, so...
Debug.LogWarning("A destroyed VseWindow still has an OnCompilationDone callback registered.");
return;
}
State state = m_Store.GetState();
UpdateCompilationErrorsDisplay(state);
if (results != null && results.errors.Count == 0)
{
// TODO : Add delegate to register to compilation Done
// VSCompilationService.NotifyChange((ISourceProvider)vsGraphModel.assetModel);
}
}
static State CreateLogNode(State previousState, CreateLogNodeAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
var stackModel = (StackBaseModel)action.StackModel;
var functionNode = stackModel.CreateStackedNode <LogNodeModel>(LogNodeModel.NodeTitle);
functionNode.LogType = action.LogType;
IConstantNodeModel constantNode = graphModel.CreateConstantNode(
"",
typeof(int).GenerateTypeHandle(graphModel.Stencil),
stackModel.Position - k_StackedTestNodesTokenOffset);
((ConstantNodeModel <int>)constantNode).value = graphModel.NodeModels.Count;
var edge = graphModel.CreateEdge(functionNode.InputPort, constantNode.OutputPort);
graphModel.LastChanges.ModelsToAutoAlign.Add(edge);
return(previousState);
}
public virtual void OnCompilationRequest(RequestCompilationOptions options)
{
CompilationOptions compilationOptions = EditorApplication.isPlaying
? CompilationOptions.LiveEditing
: CompilationOptions.Default;
if (TracingEnabled)
{
compilationOptions |= CompilationOptions.Tracing;
}
// Register
m_PluginRepository.RegisterPlugins(compilationOptions);
VSGraphModel vsGraphModel = Store.GetState().CurrentGraphModel as VSGraphModel;
if (vsGraphModel == null || vsGraphModel.Stencil == null)
{
return;
}
ITranslator translator = vsGraphModel.Stencil.CreateTranslator();
if (!translator.SupportsCompilation())
{
return;
}
if (options == RequestCompilationOptions.SaveGraph)
{
AssetDatabase.SaveAssets();
}
CompilationResult r = vsGraphModel.Compile(AssemblyType.None, translator, compilationOptions, m_PluginRepository.GetPluginHandlers());
if (Store?.GetState()?.CompilationResultModel is CompilationResultModel compilationResultModel) // TODO: could have disappeared during the await
{
compilationResultModel.lastResult = r;
OnCompilationDone(vsGraphModel, compilationOptions, r);
}
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
var affectedStacks = action.Stacks.SelectMany(stackOption => stackOption.NodeModels).OfType <NodeModel>()
.Select(model => model.ParentStackModel).Distinct();
foreach (var stack in affectedStacks)
{
Undo.RegisterCompleteObjectUndo(stack.NodeAssetReference, "Move Stacked Node(s)");
}
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
public override bool CanPasteNode(NodeModel originalModel, VSGraphModel graph)
{
switch (originalModel)
{
case VariableNodeModel variableNodeModel when variableNodeModel.DeclarationModel?.IsInputOrOutput() == true:
{
var canPasteNode = !graph.FindUsages((VariableDeclarationModel)variableNodeModel.DeclarationModel).Any();
if (!canPasteNode)
{
Debug.LogWarning(k_DuplicateInputOutputWarning);
}
return(canPasteNode);
}
case EdgePortalModel edgePortalModel:
return(graph.PortalDeclarations.Contains(edgePortalModel.DeclarationModel));
default:
return(base.CanPasteNode(originalModel, graph));
}
}
public virtual void AddStackedNode(INodeModel nodeModelInterface, int index)
{
if (!AcceptNode(nodeModelInterface.GetType()))
{
return;
}
var nodeModel = (NodeModel)nodeModelInterface;
nodeModel.AssetModel = AssetModel;
nodeModel.ParentStackModel = this;
if (index == -1)
{
m_StackedNodeModels.Add(nodeModel);
}
else
{
m_StackedNodeModels.Insert(index, nodeModel);
}
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
// We need to register before calling TransferConnections(), as edge models rely on the guid to node mapping to resolve ports
vsGraphModel.UnregisterNodeGuid(nodeModel.Guid);
vsGraphModel.RegisterNodeGuid(nodeModel);
bool insertedLast = index == -1 || m_StackedNodeModels.Count == 1 || index == m_StackedNodeModels.Count;
if (insertedLast && ModelDelegatesOutputs(nodeModelInterface))
{
TransferConnections(GraphModel, m_OutputPorts, OutputPorts);
}
vsGraphModel.LastChanges.ChangedElements.Add(nodeModel);
// Needed to add/remove/update the return value port of the node according to the function type
nodeModel.DefineNode();
}
internal static void FindInGraph(
EditorWindow host,
VSGraphModel graph,
Action <FindInGraphAdapter.FindSearcherItem> highlightDelegate,
Action <FindInGraphAdapter.FindSearcherItem> selectionDelegate
)
{
var items = graph.GetAllNodes()
.Where(x => !string.IsNullOrEmpty(x.Title))
.Select(MakeFindItems)
.ToList();
var database = SearcherDatabase.Create(items, "", false);
var searcher = new Searcher.Searcher(database, new FindInGraphAdapter(highlightDelegate));
var position = new Vector2(host.rootVisualElement.layout.center.x, 0);
SearcherWindow.Show(host, searcher, item =>
{
selectionDelegate(item as FindInGraphAdapter.FindSearcherItem);
return(true);
},
position, null, k_FindAlignment);
}
public static void CreateVariablesFromGameObjects(VSGraphModel graph, ScriptingGraphAuthoring authoringComponent, IEnumerable <GameObject> gameObjects, Vector2 position, bool actionSmartObjects)
{
foreach (var obj in gameObjects)
{
var decl = graph.CreateGraphVariableDeclaration(obj.name, TypeHandle.GameObject, true);
decl.MakeObjectReference();
ScriptingGraphAuthoring scriptingGraphAuthoring = null;
if (actionSmartObjects && (scriptingGraphAuthoring = obj.GetComponent <ScriptingGraphAuthoring>()))
{
decl.MakeSmartObject();
}
var variableNode = graph.CreateVariableNode(decl, position);
if (scriptingGraphAuthoring != null)
{
var path = AssetDatabase.GetAssetPath(scriptingGraphAuthoring.ScriptingGraph);
var referencedAssetModel = AssetDatabase.LoadAssetAtPath <VSGraphAssetModel>(path);
((SmartObjectReferenceNodeModel)variableNode).GraphReference = referencedAssetModel;
}
ScriptingGraphAuthoringEditor.BindInput(authoringComponent, decl, obj);
position += new Vector2(20, 25);
}
}
static State UpdateTypeRank(State previousState, UpdateTypeRankAction action)
{
VSGraphModel graphModel = (VSGraphModel)((GraphModel)previousState.CurrentGraphModel);
TypeHandle newType = action.IsArray
? action.VariableDeclarationModel.DataType.MakeVsArrayType(graphModel.Stencil)
: action.VariableDeclarationModel.DataType.GetGenericArguments(graphModel.Stencil).Any()
? action.VariableDeclarationModel.DataType.GetVsArrayElementType(graphModel.Stencil)
: action.VariableDeclarationModel.DataType;
Undo.RegisterCompleteObjectUndo(action.VariableDeclarationModel, "Update Type Rank");
action.VariableDeclarationModel.DataType = newType;
foreach (var usage in graphModel.FindUsages(action.VariableDeclarationModel))
{
usage.UpdateTypeFromDeclaration();
}
previousState.MarkForUpdate(UpdateFlags.RequestRebuild);
return(previousState);
}
public void OnCompilationDone(VSGraphModel vsGraphModel, CompilationOptions options, CompilationResult results)
{
if (!this)
{
// Should not happen, but it did, so...
Debug.LogWarning("A destroyed VseWindow still has an OnCompilationDone callback registered.");
return;
}
State state = m_Store.GetState();
if (vsGraphModel?.Stencil?.GeneratesCode == true)
{
VseUtility.UpdateCodeViewer(show: false, sourceIndex: SourceCodePhases.Final,
compilationResult: results,
selectionDelegate: lineMetadata =>
{
if (lineMetadata == null)
{
return;
}
GUID nodeGuid = (GUID)lineMetadata;
m_Store.Dispatch(new PanToNodeAction(nodeGuid));
});
}
//TODO: incremental re-register
m_PluginRepository.RegisterPlugins(options);
UpdateCompilationErrorsDisplay(state);
if (results != null && results.errors.Count == 0)
{
// TODO : Add delegate to register to compilation Done
// VSCompilationService.NotifyChange((ISourceProvider)vsGraphModel.assetModel);
}
}
public void StartNotifyMove(List <ISelectable> selection, Vector2 lastMousePosition)
{
m_StartPos = lastMousePosition;
m_ModelsToMove.Clear();
m_GraphModel = null;
foreach (GraphElement element in selection.OfType <GraphElement>())
{
if (element is IHasGraphElementModel hasModel &&
hasModel.GraphElementModel is INodeModel nodeModel)
{
if (m_GraphModel == null)
{
m_GraphModel = (VSGraphModel)nodeModel.GraphModel;
}
else
{
Assert.AreEqual(nodeModel.GraphModel, m_GraphModel);
}
m_ModelsToMove.Add(nodeModel);
}
}
}
static ComponentQueryDeclarationModel CreateComponentGroup(this VSGraphModel graphModel, string queryName, IEnumerable <TypeHandle> componentTypes)
{
Stencil stencil = graphModel.Stencil;
string uniqueName = graphModel.GetUniqueName(queryName);
ComponentQueryDeclarationModel field = graphModel.CreateComponentQuery(uniqueName);
if (field != null)
{
foreach (TypeHandle typeHandle in componentTypes)
{
field.AddComponent(stencil, typeHandle, ComponentDefinitionFlags.None);
}
if (componentTypes.Any())
{
field.ExpandOnCreateUI = true;
}
}
return(field);
}
