void PrepareGraph(VSGraphModel graphModel)
{
var entityTypeHandle = typeof(Entity).GenerateTypeHandle(graphModel.Stencil);
// Component creation
var scale = typeof(Scale).GenerateTypeHandle(Stencil);
var group = graphModel.CreateComponentQuery("g");
group.AddComponent(graphModel.Stencil, scale, ComponentDefinitionFlags.None);
// On update
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
m_OnUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(m_OnUpdateEntities.InstancePort, groupInstance.OutputPort);
m_CreateEntityModel = m_OnUpdateEntities.CreateStackedNode <CreateEntityNodeModel>("instantiate");
// Variable containing the new entity
m_OnUpdateEntities.CreateFunctionVariableDeclaration("newEntity", entityTypeHandle);
m_NewEntityVariable = graphModel.CreateVariableNode(
m_OnUpdateEntities.FunctionParameterModels.Single(p => p.DataType == entityTypeHandle),
Vector2.zero);
m_FloatConstantNode = (FloatConstantModel)graphModel.CreateConstantNode("float", TypeHandle.Float, Vector2.zero);
m_FloatConstantNode.value = 10f;
graphModel.CreateEdge(m_CreateEntityModel.InstancePort, m_NewEntityVariable.OutputPort);
}
public void InitBasicGraph(VSGraphModel graph)
{
Stencil stencil = graph.Stencil;
AssetDatabase.SaveAssets();
var method = graph.CreateFunction("method", Vector2.left * 200);
method.CreateFunctionVariableDeclaration("l", typeof(int).GenerateTypeHandle(stencil));
method.CreateFunctionParameterDeclaration("a", typeof(int).GenerateTypeHandle(stencil));
var log = method.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true));
var abs = graph.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Mathf), "Abs", true), new Vector2(-350, 100));
graph.CreateEdge(log.GetParameterPorts().First(), abs.OutputPort);
var xDecl = graph.CreateGraphVariableDeclaration("x", typeof(float).GenerateTypeHandle(stencil), true);
var xUsage = graph.CreateVariableNode(xDecl, new Vector2(-450, 100));
graph.CreateEdge(abs.GetParameterPorts().First(), xUsage.OutputPort);
var stack001 = graph.CreateStack(string.Empty, new Vector2(-200, 300));
stack001.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), "Log", true));
var method2 = graph.CreateFunction("method2", Vector2.left * 800);
method2.CreateFunctionRefCallNode(method);
}
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);
}
}
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);
}
}
}
}
return(previousState);
}
public void InitBasicGraph(VSGraphModel graphModel)
{
var query = graphModel.CreateComponentQuery("myQuery");
var node = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("On Update Entities", Vector2.zero);
var queryInstance = graphModel.CreateVariableNode(query, new Vector2(-145, 8));
graphModel.CreateEdge(node.InstancePort, queryInstance.OutputPort);
}
public void InitBasicGraph(VSGraphModel graphModel)
{
var query = graphModel.CreateQueryFromGameObject(GameObject);
var groupInstance = graphModel.CreateVariableNode(query, m_Position);
var node = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", m_Position + k_GroupOffset);
graphModel.CreateEdge(node.InstancePort, groupInstance.OutputPort);
}
protected IVariableModel SetupQuery(VSGraphModel graph, string name, IEnumerable <Type> components, out ComponentQueryDeclarationModel query)
{
query = graph.CreateComponentQuery(name);
foreach (var component in components)
{
query.AddComponent(Stencil, component.GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
}
return(graph.CreateVariableNode(query, Vector2.zero));
}
static OnUpdateEntitiesNodeModel CreateOnUpdateAndConnectGroup(VSGraphModel graphModel, IVariableDeclarationModel group)
{
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, groupInstance.OutputPort);
return(onUpdateEntities);
}
static OnUpdateEntitiesNodeModel CreateOnUpdateAndConnectQuery(VSGraphModel graphModel, IVariableDeclarationModel query)
{
var queryInstance = graphModel.CreateVariableNode(query, Vector2.zero);
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, queryInstance.OutputPort);
return(onUpdateEntities);
}
static void AddSharedComponentIfCriteriaMatch(VSGraphModel graphModel, FunctionModel onUpdateEntities)
{
var entityInstance = graphModel.CreateVariableNode(
onUpdateEntities.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)
),
Vector2.zero);
var addComponent = onUpdateEntities.CreateStackedNode <AddComponentNodeModel>("add");
addComponent.ComponentType = typeof(DummySharedComponent).GenerateTypeHandle(graphModel.Stencil);
graphModel.CreateEdge(addComponent.EntityPort, entityInstance.OutputPort);
addComponent.DefineNode();
}
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];
}
}
static AddComponentNodeModel CreateAddComponentInGraph(
VSGraphModel graphModel,
IVariableDeclarationModel group,
Type componentToAdd)
{
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, groupInstance.OutputPort);
var entityInstance = graphModel.CreateVariableNode(
onUpdateEntities.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)
),
Vector2.zero);
var addComponent = onUpdateEntities.CreateStackedNode <AddComponentNodeModel>("add");
addComponent.ComponentType = componentToAdd.GenerateTypeHandle(graphModel.Stencil);
graphModel.CreateEdge(addComponent.EntityPort, entityInstance.OutputPort);
return(addComponent);
}
static void CreateRemoveComponentInGraph(VSGraphModel graphModel, Type componentToRemove)
{
var component = componentToRemove.GenerateTypeHandle(graphModel.Stencil);
var query = graphModel.CreateComponentQuery("g");
query.AddComponent(graphModel.Stencil, component, ComponentDefinitionFlags.None);
var queryInstance = graphModel.CreateVariableNode(query, Vector2.zero);
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, queryInstance.OutputPort);
var entityInstance = graphModel.CreateVariableNode(
onUpdateEntities.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)
),
Vector2.zero);
var removeComponent = onUpdateEntities.CreateStackedNode <RemoveComponentNodeModel>("remove");
removeComponent.ComponentType = component;
graphModel.CreateEdge(removeComponent.EntityPort, entityInstance.OutputPort);
}
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);
}
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);
}
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);
}
}
public static List <NodeModel> SpawnAllNodeModelsInGraph(VSGraphModel graphModel)
{
List <NodeModel> spawnedNodes = new List <NodeModel>();
Stencil stencil = graphModel.Stencil;
StackModel stack;
FunctionModel funcModel;
OnUpdateEntitiesNodeModel onUpdateModel;
//--Floating Nodes--
//Stack-Derived NodeModels
spawnedNodes.Add(stack = graphModel.CreateNode <StackModel>("StackModel"));
spawnedNodes.Add(funcModel = graphModel.CreateNode <FunctionModel>("FunctionModel"));
spawnedNodes.Add(onUpdateModel = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("OnUpdateEntitiesNodeModel"));
var methodInfo = TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true);
spawnedNodes.Add(graphModel.CreateEventFunction(methodInfo, Vector2.zero));
spawnedNodes.Add(graphModel.CreateNode <OnEndEntitiesNodeModel>("OnEndEntitiesNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <OnEventNodeModel>("OnEventNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <OnStartEntitiesNodeModel>("OnStartEntitiesNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <PostUpdate>("PostUpdate"));
spawnedNodes.Add(graphModel.CreateNode <PreUpdate>("PreUpdate"));
spawnedNodes.Add(graphModel.CreateNode <KeyDownEventModel>("KeyDownEventModel"));
spawnedNodes.Add(graphModel.CreateNode <CountEntitiesNodeModel>("CountEntitiesNodeModel"));
spawnedNodes.Add(graphModel.CreateLoopStack(typeof(ForEachHeaderModel), Vector2.zero));
spawnedNodes.Add(graphModel.CreateLoopStack(typeof(WhileHeaderModel), Vector2.zero));
spawnedNodes.Add(graphModel.CreateLoopStack(typeof(ForAllEntitiesStackModel), Vector2.zero));
spawnedNodes.Add(graphModel.CreateLoopStack(typeof(CoroutineStackModel), Vector2.zero));
//Constant-typed NodeModels
spawnedNodes.Add(graphModel.CreateNode <BooleanConstantNodeModel>("BooleanConstantNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <ColorConstantModel>("ColorConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <CurveConstantNodeModel>("CurveConstantNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <DoubleConstantModel>("DoubleConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <EnumConstantNodeModel>("EnumConstantNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <FloatConstantModel>("FloatConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <GetPropertyGroupNodeModel>("GetPropertyGroupNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <InputConstantModel>("InputConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <IntConstantModel>("IntConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <LayerConstantModel>("LayerConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <LayerMaskConstantModel>("LayerMaskConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <ObjectConstantModel>("ObjectConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <QuaternionConstantModel>("QuaternionConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <StringConstantModel>("StringConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <TagConstantModel>("TagConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <Vector2ConstantModel>("Vector2ConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <Vector3ConstantModel>("Vector3ConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <Vector4ConstantModel>("Vector4ConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <ConstantSceneAssetNodeModel>("ConstantSceneAssetNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <Float2ConstantModel>("Float2ConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <Float3ConstantModel>("Float3ConstantModel"));
spawnedNodes.Add(graphModel.CreateNode <Float4ConstantModel>("Float4ConstantModel"));
//Misc
void DefineSystemConstant(SystemConstantNodeModel m)
{
m.ReturnType = typeof(float).GenerateTypeHandle(stencil);
m.DeclaringType = typeof(Mathf).GenerateTypeHandle(stencil);
m.Identifier = "PI";
}
spawnedNodes.Add(graphModel.CreateNode <SystemConstantNodeModel>("SystemConstantNodeModel", Vector2.zero, SpawnFlags.Default, DefineSystemConstant));
spawnedNodes.Add(graphModel.CreateNode <GetInputNodeModel>("GetInputNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <GetOrCreateComponentNodeModel>("GetOrCreateComponentNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <GetSingletonNodeModel>("GetSingletonNodeModel"));
spawnedNodes.Add(graphModel.CreateNode <ThisNodeModel>("ThisNodeModel"));
VariableDeclarationModel decl = graphModel.CreateGraphVariableDeclaration("MyVariableName", typeof(int).GenerateTypeHandle(graphModel.Stencil), true);
spawnedNodes.Add((NodeModel)graphModel.CreateVariableNode(decl, Vector2.zero));
spawnedNodes.Add(graphModel.CreateNode <MacroRefNodeModel>("MacroRefNodeModel"));
spawnedNodes.Add(graphModel.CreateInlineExpressionNode("2+2", Vector2.zero));
spawnedNodes.Add(graphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero));
spawnedNodes.Add(graphModel.CreateUnaryOperatorNode(UnaryOperatorKind.PostIncrement, Vector2.zero));
//--Stack-Contained Nodes--
spawnedNodes.Add(stack.CreateStackedNode <AddComponentNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <DestroyEntityNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <ForAllEntitiesNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <ForEachNodeModel>());
spawnedNodes.Add(stack.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true)));
spawnedNodes.Add(stack.CreateFunctionRefCallNode(funcModel));
spawnedNodes.Add(stack.CreateStackedNode <InstantiateNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <CreateEntityNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <IfConditionNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <LogNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <RemoveComponentNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <SetComponentNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <SetPositionNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <SetRotationNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <WhileNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <SetPropertyGroupNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <SetVariableNodeModel>());
spawnedNodes.Add(stack.CreateStackedNode <CoroutineNodeModel>());
spawnedNodes.Add(funcModel.CreateStackedNode <ReturnNodeModel>());
TypeHandle eventTypeHandle = typeof(DummyEvent).GenerateTypeHandle(stencil);
spawnedNodes.Add(onUpdateModel.CreateStackedNode <SendEventNodeModel>("SendEventNodeModel", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle));
return(spawnedNodes);
}
