public IEnumerable <IPortModel> GetPortsForComponent(TypeHandle th)
{
return(m_PortDescriptions
.FirstOrDefault(pm => pm.Component == th)
?.GetFieldIds()
.Select(id => InputsById[id])
?? Enumerable.Empty <IPortModel>());
}
public static TypeSyntax ToTypeSyntax(this TypeHandle handle, Stencil stencil)
{
if (handle.GraphModelReference != null)
{
return(handle.GraphModelReference.ToTypeSyntax());
}
return(handle.Resolve(stencil).ToTypeSyntax());
}
public static ComponentPortsDescription FromData(TypeHandle componentType, IReadOnlyList <Tuple <string, TypeHandle> > componentDescriptions, string prefix = null)
{
var result = new ComponentPortsDescription(componentType, componentDescriptions.Count, prefix)
{
m_FieldNames = componentDescriptions.Select(t => t.Item1).ToList()
};
return(result);
}
public void DeleteComponentOperation(TypeHandle th)
{
var i = m_AdditionalComponents.FindIndex(compOps => compOps.Type == th);
if (i != -1)
{
m_AdditionalComponents.RemoveAt(i);
}
}
internal ComponentPortsDescription AddPortsForComponent(TypeHandle comp, string prefix = null)
{
var inputsFromComponentType = HighLevelNodeModelHelpers.GetDataInputsFromComponentType(Stencil, comp).ToList();
var description = ComponentPortsDescription.FromData(comp, inputsFromComponentType, prefix);
foreach (Tuple <string, TypeHandle> field in inputsFromComponentType)
{
AddDataInput($"{field.Item1}", field.Item2, description.GetFieldId(field.Item1));
}
return(description);
}
internal static IEnumerable <Tuple <string, TypeHandle> > GetDataInputsFromComponentType(
Stencil stencil,
TypeHandle componentTypeHandle
)
{
var componentType = componentTypeHandle.Resolve(stencil);
var fields = componentType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var type = HasSinglePredefinedFieldType(fields)
? fields[0].FieldType
: componentType;
return(type.GetFields(BindingFlags.Public | BindingFlags.Instance)
.Select(f => new Tuple <string, TypeHandle>(f.Name, f.FieldType.GenerateTypeHandle(stencil))));
}
public static void AddCriterion(this ICriteriaModelContainer criteriaModelContainer,
CriteriaModel criteriaModel,
TypeHandle typeHandle,
TypeMember typeMember,
BinaryOperatorKind operatorKind)
{
if (!criteriaModelContainer.CriteriaModels.Contains(criteriaModel))
{
return;
}
Undo.RegisterCompleteObjectUndo(criteriaModelContainer.SerializableAsset, "Add Criterion To Criteria Model");
criteriaModel.AddCriterion((VSGraphModel)criteriaModelContainer.GraphModel, typeHandle, typeMember, operatorKind);
}
public SearcherFilter GetEdgeSearcherFilter(IEdgeModel edgeModel)
{
Type it = edgeModel.InputPortModel.DataType.Resolve(m_Stencil);
IPortModel opm = edgeModel.OutputPortModel;
TypeHandle oth = opm.DataType == TypeHandle.ThisType ? m_Stencil.GetThisType() : opm.DataType;
Type ot = oth.Resolve(m_Stencil);
return(new SearcherFilter(SearcherContext.Graph)
.WithVisualScriptingNodesExcept(new[] { typeof(ThisNodeModel) }) // TODO : We should be able to determine if a VSNode type has input port instead of doing this
.WithFields(ot, it)
.WithUnaryOperators(ot, opm.NodeModel is IConstantNodeModel)
.WithBinaryOperators(ot)
.WithMethods(ot, it)
.WithProperties(ot, it, false));
}
public virtual SearcherFilter GetOutputToStackSearcherFilter(IPortModel portModel, IStackModel stackModel)
{
// TODO : Need to be handled by TypeHandle.Resolve
TypeHandle typeHandle = portModel.DataType == TypeHandle.ThisType ? m_Stencil.GetThisType() : portModel.DataType;
Type type = typeHandle.Resolve(m_Stencil);
GraphAssetModel assetModel = portModel.AssetModel as GraphAssetModel;
return(new SearcherFilter(SearcherContext.Stack)
.WithVisualScriptingNodes()
.WithFields(type)
.WithUnaryOperators(type)
.WithIfConditions(typeHandle, stackModel)
.WithMethods(type)
.WithProperties(type, false)
.WithGraphAsset(assetModel));
}
public SearcherFilter GetOutputToGraphSearcherFilter(IPortModel portModel)
{
// TODO : Need to be handled by TypeHandle.Resolve
TypeHandle typeHandle = portModel.DataType == TypeHandle.ThisType ? m_Stencil.GetThisType() : portModel.DataType;
Type type = typeHandle.Resolve(m_Stencil);
VSGraphAssetModel assetModel = portModel.AssetModel as VSGraphAssetModel;
return(new SearcherFilter(SearcherContext.Graph)
.WithVisualScriptingNodes()
.WithFields(type)
.WithUnaryOperators(type, portModel.NodeModel is IConstantNodeModel)
.WithBinaryOperators(type)
.WithMethods(type)
.WithProperties(type)
.WithGraphAsset(assetModel));
}
public virtual List <SearcherDatabase> GetTypeMembersSearcherDatabases(TypeHandle typeHandle)
{
// TODO : Need to be handled by TypeHandle.Resolve
Type type = typeHandle == TypeHandle.ThisType
? m_Stencil.GetThisType().Resolve(m_Stencil)
: typeHandle.Resolve(m_Stencil);
return(new List <SearcherDatabase>
{
new GraphElementSearcherDatabase(m_Stencil)
.AddMembers(
new[] { type },
MemberFlags.Field | MemberFlags.Method | MemberFlags.Property | MemberFlags.Extension,
BindingFlags.Instance | BindingFlags.Public
)
.Build()
});
}
public virtual Type GetConstantNodeModelType(TypeHandle typeHandle)
{
if (s_TypeToConstantNodeModelTypeCache == null)
{
s_TypeToConstantNodeModelTypeCache = new Dictionary <TypeHandle, Type>
{
{ typeof(Boolean).GenerateTypeHandle(this), typeof(BooleanConstantNodeModel) },
{ typeof(Color).GenerateTypeHandle(this), typeof(ColorConstantModel) },
{ typeof(AnimationCurve).GenerateTypeHandle(this), typeof(CurveConstantNodeModel) },
{ typeof(Double).GenerateTypeHandle(this), typeof(DoubleConstantModel) },
{ typeof(Unknown).GenerateTypeHandle(this), typeof(EnumConstantNodeModel) },
{ typeof(Single).GenerateTypeHandle(this), typeof(FloatConstantModel) },
{ typeof(InputName).GenerateTypeHandle(this), typeof(InputConstantModel) },
{ typeof(Int32).GenerateTypeHandle(this), typeof(IntConstantModel) },
{ typeof(LayerName).GenerateTypeHandle(this), typeof(LayerConstantModel) },
{ typeof(LayerMask).GenerateTypeHandle(this), typeof(LayerMaskConstantModel) },
{ typeof(Object).GenerateTypeHandle(this), typeof(ObjectConstantModel) },
{ typeof(Quaternion).GenerateTypeHandle(this), typeof(QuaternionConstantModel) },
{ typeof(String).GenerateTypeHandle(this), typeof(StringConstantModel) },
{ typeof(TagName).GenerateTypeHandle(this), typeof(TagConstantModel) },
{ typeof(Type).GenerateTypeHandle(this), typeof(TypeConstantModel) },
{ typeof(Vector2).GenerateTypeHandle(this), typeof(Vector2ConstantModel) },
{ typeof(Vector3).GenerateTypeHandle(this), typeof(Vector3ConstantModel) },
{ typeof(Vector4).GenerateTypeHandle(this), typeof(Vector4ConstantModel) },
{ typeof(SceneAsset).GenerateTypeHandle(this), typeof(ConstantSceneAssetNodeModel) },
};
}
if (s_TypeToConstantNodeModelTypeCache.TryGetValue(typeHandle, out var result))
{
return(result);
}
Type t = typeHandle.Resolve(this);
if (t.IsEnum || t == typeof(Enum))
{
return(typeof(EnumConstantNodeModel));
}
return(null);
}
public void SetComponentOperation(TypeHandle type, ComponentOperationType operation)
{
var i = m_AdditionalComponents.FindIndex(compOps => compOps.Type == type);
if (i == -1)
{
m_AdditionalComponents.Add(new ComponentOperation(type, operation));
}
else if (operation == ComponentOperationType.AddComponent ||
operation == ComponentOperationType.RemoveComponent ||
operation == ComponentOperationType.SetComponent)
{
m_AdditionalComponents[i] =
new ComponentOperation(type, operation, m_AdditionalComponents[i].FromArchetype);
}
else
{
throw new ArgumentOutOfRangeException(nameof(operation), operation, null);
}
}
public static TypeSyntax ToTypeSyntax(this TypeHandle handle, Stencil stencil)
{
return(handle.Resolve(stencil).ToTypeSyntax());
}
ComponentPortsDescription(TypeHandle component, int capacity, string prefix = null)
{
Component = component;
m_FieldNames = new List <string>(capacity);
m_Prefix = prefix;
}
protected override void UpdateInputPortModels()
{
Port.CreateInputPort(m_Store, Model.InstancePort, inputContainer, inputContainer);
Port.CreateInputPort(m_Store, Model.EntityPort, titleContainer, inputContainer);
//TODO deal with presence of same component type in both lists
foreach (var componentOperation in Model.GetEditableComponents())
{
TypeHandle compType = componentOperation.Type;
var componentContainer = new VisualElement {
name = "instantiateComponentNode"
};
var componentTitleContainer = new VisualElement {
name = "componentDataTitle"
};
componentContainer.Add(new VisualElement {
name = "componentSeparatorLine"
});
componentContainer.Add(componentTitleContainer);
var deleteComponentButton = new Button {
name = "deleteComponentIcon"
};
deleteComponentButton.clickable.clicked += () => { DeleteComponentOperation(compType); };
componentTitleContainer.Insert(0, deleteComponentButton);
deleteComponentButton.EnableInClassList("deletable", !componentOperation.FromArchetype);
componentTitleContainer.Add(deleteComponentButton);
componentTitleContainer.Add(new Label(compType.Name(Model.GraphModel.Stencil))
{
name = "componentTitle"
});
componentTitleContainer.Add(new VisualElement {
name = "filler"
});
var operationType = new EnumField(componentOperation.OperationType)
{
name = "componentOperationType"
};
//Do I need to unregister it afterwards?
//Also, allocation a closure for each component operations... meh?
operationType.RegisterValueChangedCallback(eventValue => SetComponentOperation(compType, (ComponentOperation.ComponentOperationType)eventValue.newValue));
componentTitleContainer.Add(operationType);
inputContainer.Add(componentContainer);
if (componentOperation.OperationType != ComponentOperation.ComponentOperationType.RemoveComponent)
{
var componentPortsContainer = new VisualElement {
name = "componentDataPorts"
};
componentContainer.Add(componentPortsContainer);
foreach (var port in Model.GetPortsForComponent(componentOperation.Type))
{
Port.CreateInputPort(m_Store, port, componentPortsContainer, componentPortsContainer);
}
}
}
}
void DeleteComponentOperation(TypeHandle componentType)
{
var action = new RemoveOperationForComponentTypeInInstantiateNodeAction(Model, componentType);
m_Store.Dispatch(action);
}
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);
}
void AddComponentOperation(TypeHandle componentType)
{
var action = new SetOperationForComponentTypeInCreateEntityNodeAction(Model, componentType);
m_Store.Dispatch(action);
}
public static Type Resolve(this TypeHandle th, Stencil stencil)
{
return(th.Resolve(stencil.GraphContext.TypeHandleSerializer));
}
public static Type Resolve(this TypeHandle th, ITypeBasedTypeHandleSerializer serializer)
{
return(serializer.ResolveType(th));
}
public Type ResolveType(TypeHandle th)
{
return(Deserialize(th.Identification));
}
public VSGraphModel ResolveGraph(TypeHandle th)
{
return(th.GraphModelReference != null ? th.GraphModelReference : null);
}
public static ITypeMetadata GetMetadata(this TypeHandle th, Stencil stencil)
{
return(th.GetMetadata(stencil.GraphContext.TypeMetadataResolver));
}
public static ITypeMetadata GetMetadata(this TypeHandle th, ITypeMetadataResolver resolver)
{
return(resolver.Resolve(th));
}
public static Type Resolve(this TypeHandle th, CSharpTypeSerializer serializer)
{
return(serializer.ResolveType(th));
}
public ComponentOperation(TypeHandle type, ComponentOperationType operationType, bool fromArchetype = false)
{
Type = type;
OperationType = operationType;
FromArchetype = fromArchetype;
}
void SetComponentOperation(TypeHandle componentType, ComponentOperation.ComponentOperationType newValue)
{
var action = new SetOperationForComponentTypeInInstantiateNodeAction(Model, componentType, newValue);
m_Store.Dispatch(action);
}
public Type ResolveType(TypeHandle th)
{
return(m_TypeSerializer.ResolveType(th));
}
public void DeleteComponentOperation(TypeHandle type) => m_AdditionalComponents.Remove(type);