public BlackboardVariablePropertyView(Store store, IVariableDeclarationModel variableDeclarationModel, Blackboard.RebuildCallback rebuildCallback, Stencil stencil) : base(variableDeclarationModel, rebuildCallback) { m_Store = store; m_Stencil = stencil; RegisterCallback <AttachToPanelEvent>(OnAttachToPanel); RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel); if (variableDeclarationModel.VariableType != VariableType.FunctionVariable && variableDeclarationModel.VariableType != VariableType.GraphVariable) { return; } if (!variableDeclarationModel.InitializationModel?.NodeAssetReference) { if (stencil.GetVariableInitializer().RequiresInitialization(variableDeclarationModel)) { m_InitializationElement = new Button(OnInitializationButton) { text = "Create Init value" }; m_InitializationElement.AddToClassList("rowButton"); } } else { m_InitializationObject = new SerializedObject(variableDeclarationModel.InitializationModel.NodeAssetReference); m_InitializationObject.Update(); m_InitializationElement = new IMGUIContainer(OnInitializationGUI); } }
public override ExpressionSyntax GetSingletonVariable(IVariableDeclarationModel variable) { var ext = Parent.GetSingletonVariable(variable); if (!HasParameter(RootContext.SingletonVariableName)) { // If not jobContext (readOnly access) we have to pass the singleton component as reference if (IsJobContext) { m_Parameters.Add( Argument(ext), Parameter(Identifier(((IdentifierNameSyntax)ext).Identifier.Text)) .WithType(TypeSystem.BuildTypeSyntax(variable.DataType.Resolve(IterationContext.Stencil)))); } else { m_Parameters.Add( Argument(IdentifierName(RootContext.SingletonVariableName)) .WithRefOrOutKeyword(Token(SyntaxKind.RefKeyword)), Parameter(Identifier(RootContext.SingletonVariableName)) .WithModifiers(TokenList(Token(SyntaxKind.RefKeyword))) .WithType(IdentifierName(RootContext.SingletonComponentTypeName))); } } return(ext); }
protected void AddUsage(IVariableDeclarationModel fieldModel) { int prevCount = GetFloatingVariableModels(GraphModel).Count(); m_Store.Dispatch(new CreateVariableNodesAction(fieldModel, Vector2.one)); Assume.That(GetFloatingVariableModels(GraphModel).Count(), Is.EqualTo(prevCount + 1)); }
public void ReorderGraphVariableDeclaration(IVariableDeclarationModel variableDeclarationModel, int index) { Assert.IsTrue(index >= 0); Undo.RegisterCompleteObjectUndo((Object)AssetModel, "Reorder Graph Variable Declaration"); var varDeclarationModel = (VariableDeclarationModel)variableDeclarationModel; if (varDeclarationModel.VariableType == VariableType.GraphVariable) { var oldIndex = m_GraphVariableModels.IndexOf(varDeclarationModel); m_GraphVariableModels.RemoveAt(oldIndex); if (index > oldIndex) { index--; // the actual index could have shifted due to the removal } if (index >= m_GraphVariableModels.Count) { m_GraphVariableModels.Add(varDeclarationModel); } else { m_GraphVariableModels.Insert(index, varDeclarationModel); } LastChanges.ChangedElements.Add(variableDeclarationModel); LastChanges.DeletedElements++; } }
public static StatementSyntax DeclareLocalVariable(this IVariableDeclarationModel decl, RoslynTranslator translator, bool useInitialization = true) { var variableDeclarationSyntax = decl.DeclareVariable(translator, useInitialization, false); return(SyntaxFactory.LocalDeclarationStatement(variableDeclarationSyntax)); }
static VariableDeclarationSyntax DeclareVariable(this IVariableDeclarationModel decl, RoslynTranslator translator, bool useInitialization, bool isField) { bool canBeImplicitlyTyped = !isField; bool initialized = false; var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(decl.VariableName)); if (useInitialization && translator.Stencil.RequiresInitialization(decl)) { if (decl.InitializationModel != null) { var expression = translator.BuildNode(decl.InitializationModel).SingleOrDefault() as ExpressionSyntax; varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(expression)); initialized = true; } } VariableDeclarationSyntax varDeclaration; if (canBeImplicitlyTyped && initialized) { varDeclaration = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var")); } else { varDeclaration = SyntaxFactory.VariableDeclaration(decl.DataType.ToTypeSyntax(translator.Stencil)); } return(varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator))); }
public static StatementSyntax DeclareLoopCountVariable(this IVariableDeclarationModel decl, ExpressionSyntax collectionNodeModel, string collectionName, RoslynTranslator translator) { if (collectionNodeModel == null) { return(decl.DeclareLocalVariable(translator)); } return(SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.IntKeyword))) .WithVariables( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(decl.Name)) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, string.IsNullOrEmpty(collectionName) ? collectionNodeModel : SyntaxFactory.IdentifierName(collectionName), SyntaxFactory.IdentifierName("Count")))))))); }
public bool GetComponentFromEntityOrComponentPort( INodeModel model, IPortModel entityOrComponentPort, out ComponentQueryDeclarationModel query, out ExpressionSyntax setValue, AccessMode mode = AccessMode.Read) { setValue = null; var componentVariableType1 = entityOrComponentPort.DataType; IVariableDeclarationModel varNode = null; if (!entityOrComponentPort.Connected) // assume current iteration context entity variable { varNode = context.IterationContext.Query.ItemVariableDeclarationModel; } else { varNode = (entityOrComponentPort.ConnectionPortModels?.FirstOrDefault()?.NodeModel as VariableNodeModel)?.DeclarationModel; } if (varNode != null && varNode.DataType == typeof(Entity).GenerateTypeHandle(Stencil) && varNode.Owner is IIteratorStackModel iteratorStackModel) { query = iteratorStackModel.ComponentQueryDeclarationModel; if (query.Components.Any(x => x.Component.TypeHandle == componentVariableType1)) { context.RecordComponentAccess(context.IterationContext, componentVariableType1, mode); var componentVarName = context.GetComponentVariableName(iteratorStackModel, componentVariableType1); setValue = IdentifierName(componentVarName); } else { var componentName = componentVariableType1.Resolve(Stencil).FriendlyName(); var queryCopy = query; AddError(model, $"A component of type {componentName} is required, which the query {query.Name} doesn't specify", new CompilerQuickFix($"Add {componentName} to the query", s => s.Dispatch(new AddComponentToQueryAction( queryCopy, componentVariableType1, ComponentDefinitionFlags.None))) ); return(false); } } if (setValue == null) { context.RecordComponentAccess(context.IterationContext, componentVariableType1, mode); setValue = BuildPort(entityOrComponentPort).FirstOrDefault() as ExpressionSyntax; } query = null; return(true); }
public TokenDeclaration(Store store, IVariableDeclarationModel model, GraphView graphView) { m_Pill = new Pill(); Add(m_Pill); if (model is IObjectReference modelReference) { if (modelReference is IExposeTitleProperty titleProperty) { #if UNITY_2019_3_OR_NEWER m_TitleLabel = m_Pill.Q <Label>("title-label"); #else m_TitleLabel = m_Pill.Q <Label>("title-label").ReplaceWithBoundLabel(); #endif m_TitleLabel.bindingPath = titleProperty.TitlePropertyName; } } RegisterCallback <AttachToPanelEvent>(OnAttachToPanel); RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel); styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "Token.uss")); Declaration = model; m_Store = store; m_GraphView = graphView; m_Pill.icon = Declaration.IsExposed ? VisualScriptingIconUtility.LoadIconRequired("GraphView/Nodes/BlackboardFieldExposed.png") : null; m_Pill.text = Declaration.Title; if (model != null) { capabilities = VseUtility.ConvertCapabilities(model); } var variableModel = model as VariableDeclarationModel; Stencil stencil = store.GetState().CurrentGraphModel?.Stencil; if (variableModel != null && stencil && variableModel.DataType.IsValid) { string friendlyTypeName = variableModel.DataType.GetMetadata(stencil).FriendlyName; Assert.IsTrue(!string.IsNullOrEmpty(friendlyTypeName)); tooltip = $"{variableModel.VariableString} declaration of type {friendlyTypeName}"; if (!string.IsNullOrEmpty(variableModel.Tooltip)) { tooltip += "\n" + variableModel.Tooltip; } } SetClasses(); this.EnableRename(); if (model != null) { viewDataKey = model.GetId(); } }
/// <summary> /// Initializes a new instance of the <see cref="CollapseVariableInBlackboard"/> class. /// </summary> /// <param name="variableDeclarationModel">The variable to update.</param> /// <param name="collapse">Whether to collapse the variable row in the blackboard.</param> public CollapseVariableInBlackboard(IVariableDeclarationModel variableDeclarationModel, bool collapse) : this() { VariableDeclarationModel = variableDeclarationModel; Collapse = collapse; UndoString = Collapse ? "Collapse Variable Declaration" : "Expand Variable Declaration"; }
/// <summary> /// Initializes a new instance of the <see cref="ExposeVariableCommand"/> class. /// </summary> /// <param name="variableDeclarationModel">The variable to update.</param> /// <param name="exposed">Whether the variable should be exposed.</param> public ExposeVariableCommand(IVariableDeclarationModel variableDeclarationModel, bool exposed) : this() { VariableDeclarationModel = variableDeclarationModel; Exposed = exposed; UndoString = Exposed ? "Show Variable" : "Hide Variable"; }
public void MoveVariableDeclaration(IVariableDeclarationModel variableDeclarationModel, IHasVariableDeclaration destination) { var currentOwner = variableDeclarationModel.Owner; var model = (VariableDeclarationModel)variableDeclarationModel; Undo.RegisterCompleteObjectUndo(GetUnityObjectBehindInstance(currentOwner), "Move Variable Declaration"); Undo.RegisterCompleteObjectUndo(GetUnityObjectBehindInstance(destination), "Move Variable Declaration"); Undo.RegisterCompleteObjectUndo(model, "Move Variable Declaration"); currentOwner.VariableDeclarations.Remove(model); destination.VariableDeclarations.Add(model); LastChanges.ChangedElements.Add(model); model.Owner = destination; Object GetUnityObjectBehindInstance(IHasVariableDeclaration container) { if (container is INodeModel nodeModel) { return(nodeModel.NodeAssetReference); } if (container is VSGraphModel vsGraphModel) { return(vsGraphModel); } return(null); } }
public override ExpressionSyntax GetSingletonVariable(IVariableDeclarationModel variable) { var exp = Parent.GetSingletonVariable(variable); var key = $"{RootContext.SingletonComponentTypeName}{variable.VariableName}"; return(GetCachedValue(key, exp, variable.DataType)); }
static AddComponentNodeModel CreateAddComponentInGraph( VSGraphModel graphModel, IVariableDeclarationModel query, Type componentToAdd) { return(CreateAddComponentInGraph <OnUpdateEntitiesNodeModel>(graphModel, query, componentToAdd)); }
internal static bool VariableIsAGeneratedEcsComponent(this IVariableDeclarationModel variableDeclarationModel, out IIteratorStackModel iteratorStackModel) { var isEntity = variableDeclarationModel.DataType.Equals(typeof(Entity).GenerateTypeHandle(variableDeclarationModel.GraphModel.Stencil)); iteratorStackModel = variableDeclarationModel is LoopVariableDeclarationModel loopDecl?loopDecl.GetComponentQueryDeclarationModel() : null; return(!isEntity && iteratorStackModel != null && (((VariableDeclarationModel)variableDeclarationModel).variableFlags & VariableFlags.Generated) != 0); }
public static MemberInfoValue ToMemberInfoValue(this IVariableDeclarationModel decl, IGraphBasedTypeHandleSerializer serializer) { return(new MemberInfoValue( serializer.GenerateTypeHandle(decl.GraphModel as VSGraphModel), decl.DataType, decl.Name, MemberTypes.Field)); }
public static MemberInfoValue ToMemberInfoValue(this IVariableDeclarationModel decl, Stencil stencil) { return(new MemberInfoValue( stencil.GenerateTypeHandle(decl.GraphModel as VSGraphModel), decl.DataType, decl.Name, MemberTypes.Field)); }
private static BindingId GetExistingBinding(IVariableDeclarationModel graphVariableModel, ScriptingGraphAuthoring authoring, out ScriptingGraphAuthoring.InputBindingAuthoring binding) { var id = GraphBuilder.GetBindingId(graphVariableModel); binding = GetExistingBinding(authoring, id); return(id); }
public CreateVariableNodesAction(IVariableDeclarationModel graphElementModel, Vector2 mousePosition, IEnumerable <IGTFEdgeModel> edgeModelsToDelete = null, IPortModel connectAfterCreation = null, bool autoAlign = false) { VariablesToCreate = new List <Tuple <IVariableDeclarationModel, Vector2> >(); VariablesToCreate.Add(Tuple.Create(graphElementModel, mousePosition)); EdgeModelsToDelete = edgeModelsToDelete; ConnectAfterCreation = connectAfterCreation; AutoAlign = autoAlign; }
VisualElement CreateExtendedFieldView(Store store, IVariableDeclarationModel variableDeclarationModel, Blackboard.RebuildCallback rebuild) { return(new BlackboardVariablePropertyView(store, variableDeclarationModel, rebuild, m_Stencil) .WithTypeSelector() .WithExposedToggle() .WithTooltipField() .WithInitializationField()); }
protected BlackboardExtendedFieldView(IVariableDeclarationModel model, Blackboard.RebuildCallback rebuildCallback) { userData = model; m_RebuildCallback = rebuildCallback; styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "Blackboard.uss")); AddToClassList("blackboardFieldPropertyView"); }
public static IVariableModel CreateVariableNodeNoUndo(this VSGraphModel graphModel, IVariableDeclarationModel declarationModel, Vector2 position, SpawnFlags spawnFlags = SpawnFlags.Default) { if (declarationModel == null) { return(graphModel.CreateNode <ThisNodeModel>("this", position, SpawnFlags.CreateNodeAsset)); } return(graphModel.CreateNode <VariableNodeModel>(declarationModel.Title, position, spawnFlags, v => v.DeclarationModel = declarationModel)); }
public static IVariableModel CreateVariableNode(this IGraphModel graphModel, IVariableDeclarationModel declarationModel, Vector2 position, SpawnFlags spawnFlags = SpawnFlags.Default, GUID?guid = null) { if (declarationModel == null) { return(graphModel.CreateNode <ThisNodeModel>("this", position, spawnFlags, guid: guid)); } return(graphModel.CreateNode <VariableNodeModel>(declarationModel.Title, position, spawnFlags, v => v.DeclarationModel = declarationModel, guid)); }
public static FieldDeclarationSyntax DeclareField(this IVariableDeclarationModel decl, RoslynTranslator translator, bool useInitialization = true) { var declaration = decl.DeclareVariable(translator, useInitialization, true); var modifier = SyntaxFactory.Token(decl.IsExposed ? SyntaxKind.PublicKeyword : SyntaxKind.PrivateKeyword); var fieldDeclaration = SyntaxFactory.FieldDeclaration(declaration) .WithModifiers(SyntaxFactory.TokenList(modifier)); return(fieldDeclaration); }
public void MoveVariableDeclaration(IVariableDeclarationModel variableDeclarationModel, IHasVariableDeclaration destination) { var currentOwner = variableDeclarationModel.Owner; var model = (VariableDeclarationModel)variableDeclarationModel; Undo.RegisterCompleteObjectUndo(model.SerializableAsset, "Move Variable Declaration"); currentOwner.VariableDeclarations.Remove(model); destination.VariableDeclarations.Add(model); LastChanges.ChangedElements.Add(model); model.Owner = destination; }
public bool RequiresInitialization(IVariableDeclarationModel decl) { if (decl == null) { return(false); } VariableType variableType = decl.VariableType; Type dataType = CSharpTypeSerializer.ResolveType(decl.DataType); return((variableType == VariableType.GraphVariable) && (dataType.IsValueType || dataType == typeof(string))); }
protected IVariableDeclarationModel CreateFunctionVariableDeclaration <T>(Func <FunctionModel> method, string localName) { int prevCount = method().FunctionVariableModels.Count(); m_Store.Dispatch(new CreateFunctionVariableDeclarationAction(method(), localName, typeof(T).GenerateTypeHandle(Stencil))); Assert.AreEqual(prevCount + 1, method().FunctionVariableModels.Count()); IVariableDeclarationModel decl = GetFunctionVariable(method(), localName); Assume.That(decl, Is.Not.Null); Assume.That(decl.Title, Is.EqualTo(localName)); return(decl); }
protected IVariableDeclarationModel CreateGraphVariableDeclaration(string fieldName, Type type) { int prevCount = GraphModel.GraphVariableModels.Count(); m_Store.Dispatch(new CreateGraphVariableDeclarationAction(fieldName, false, type.GenerateTypeHandle(Stencil))); Assert.AreEqual(prevCount + 1, GraphModel.GraphVariableModels.Count()); IVariableDeclarationModel decl = GetGraphVariableDeclaration(fieldName); Assume.That(decl, Is.Not.Null); Assume.That(decl.Title, Is.EqualTo(fieldName)); return(decl); }
public override void RecordEntityAccess(IVariableDeclarationModel model) { Parent.RecordEntityAccess(model); if (HasParameter(model.Name)) { return; } m_Parameters.Add( Argument(IdentifierName(model.Name)), Parameter(Identifier(model.Name)) .WithType(TypeSystem.BuildTypeSyntax(typeof(Entity)))); }
/// <summary> /// Sets the expanded state of the variable declaration model in the blackboard. /// </summary> /// <param name="model">The model for which to set the state.</param> /// <param name="expanded">True if the variable should be expanded, false otherwise.</param> public void SetVariableDeclarationModelExpanded(IVariableDeclarationModel model, bool expanded) { bool isExpanded = m_State.GetVariableDeclarationModelExpanded(model); if (isExpanded && !expanded) { m_State.m_BlackboardExpandedRowStates?.Remove(model.Guid.ToString()); m_State.SetUpdateType(UpdateType.Complete); } else if (!isExpanded && expanded) { m_State.m_BlackboardExpandedRowStates?.Add(model.Guid.ToString()); m_State.SetUpdateType(UpdateType.Complete); } }