static void UpdateComponentQueryInternal(State previousState, ComponentQueryDeclarationModel queryDeclarationModel, IComponentQueryAction queryAction, int oldIndex, int newIndex) { UnityEngine.Assertions.Assert.IsTrue(queryAction is MoveComponentInQueryAction || (oldIndex == -1 && newIndex == -1)); s_CachedVariableList.Clear(); s_CachedVariableList.AddRange(((VSGraphModel)previousState.CurrentGraphModel).FindUsages(queryDeclarationModel)); foreach (var usage in s_CachedVariableList) { IPortModel output = usage.OutputPort; if (output != null) { s_CachedList.Clear(); s_CachedList.AddRange(queryDeclarationModel.GraphModel.GetConnections(output)); foreach (var connected in s_CachedList) { if (connected.NodeModel is IIteratorStackModel iteratorStackModel) { Assert.IsTrue(iteratorStackModel is IPrivateIteratorStackModel); ForAllEntitiesStackModel.UpdateComponentsVariables((IPrivateIteratorStackModel)iteratorStackModel, queryAction, oldIndex, newIndex); } connected.NodeModel.OnConnection(connected, output); } } previousState.CurrentGraphModel.LastChanges.ChangedElements.Add(usage); } }
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 CriteriaSubSection(Stencil stencil, ComponentQueryDeclarationModel componentQueryDeclarationModel, Blackboard blackboard) : base(SectionTitleText, graphElementModel: null, store: blackboard.Store, parentElement: null, rebuildCallback: null, canAcceptDrop: null) { m_Stencil = stencil; m_Blackboard = blackboard; name = "criteriaSection"; userData = name; AddToClassList("subSection"); ExpandedButton.style.display = DisplayStyle.None; int nbRows = 0; BuildCriteriaForComponentQuery(componentQueryDeclarationModel, ref nbRows, blackboard); viewDataKey = "BlackboardCriteriaSection"; Expanded = true; SectionTitle.text += " (" + nbRows + ")"; }
public void OneGroupIterationSystem([Values] CodeGenMode mode) { SetupTestGraph(mode, g => { ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1"); TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None); IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set"); var member = new TypeMember(TypeHandle.Float, new List <string> { nameof(Translation.Value), nameof(Translation.Value.x) }); set.AddMember(member); IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); ((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f; }, (manager, entityIndex, e) => manager.AddComponentData(e, new Translation { Value = { x = entityIndex } }), (manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f))); }
public ComponentsSubSection(Stencil stencil, ComponentQueryDeclarationModel componentQueryDeclarationModel, Blackboard blackboard) : base(SectionTitleText, graphElementModel: null, store: blackboard.Store, parentElement: null, rebuildCallback: null, canAcceptDrop: null) { m_Stencil = stencil; name = "componentsSection"; userData = name; AddToClassList("subSection"); int nbRows = 0; ExpandedButton.style.display = DisplayStyle.None; ExpandableRowTitleContainer.Add(new Button(() => { AddComponentToQuery(componentQueryDeclarationModel); }) { name = "addComponentButton", text = "+" }); componentQueryDeclarationModel.ExpandOnCreateUI = false; nbRows += AddRows(componentQueryDeclarationModel, ExpandedContainer); viewDataKey = "blackboardComponentsSection"; Expanded = true; SectionTitle.text += " (" + nbRows + ")"; }
int AddCriteriaModelRows(ComponentQueryDeclarationModel componentQueryDeclarationModel, ExpandedContainer expandedContainer) { foreach (var criteriaModel in componentQueryDeclarationModel.CriteriaModels) { AddCriteriaModelRow(criteriaModel, componentQueryDeclarationModel, expandedContainer); } return(componentQueryDeclarationModel.CriteriaModels.Count); }
public AddComponentToQueryAction(ComponentQueryDeclarationModel componentQueryDeclarationModel, TypeHandle typeHandle, ComponentDefinitionFlags creationFlags ) { ComponentQueryDeclarationModel = componentQueryDeclarationModel; TypeHandle = typeHandle; CreationFlags = creationFlags; }
static State AddComponentToQuery(State previousState, AddComponentToQueryAction action) { ComponentQueryDeclarationModel queryDeclarationModel = action.ComponentQueryDeclarationModel; Undo.RegisterCompleteObjectUndo(queryDeclarationModel, "Add Component To Query"); queryDeclarationModel.AddComponent(previousState.CurrentGraphModel.Stencil, action.TypeHandle, action.CreationFlags); queryDeclarationModel.ExpandOnCreateUI = true; UpdateComponentQuery(previousState, queryDeclarationModel, action); return(previousState); }
public MoveComponentInQueryAction(ComponentQueryDeclarationModel componentQueryDeclarationModel, ComponentDefinition componentDefinition, ComponentDefinition targetComponentDefinition, bool insertAtEnd) { ComponentQueryDeclarationModel = componentQueryDeclarationModel; ComponentDefinition = componentDefinition; TargetComponentDefinition = targetComponentDefinition; InsertAtEnd = insertAtEnd; }
void BuildCriteriaForComponentQuery(ComponentQueryDeclarationModel componentQueryDeclarationModel, ref int nbRows, Blackboard blackboard) { Sortable = true; ExpandableRowTitleContainer.AddManipulator(new Clickable(() => {})); ExpandableRowTitleContainer.Add(new Button(() => { AddCriteriaModel(componentQueryDeclarationModel); }) { name = "addCriteriaButton", text = "+" }); componentQueryDeclarationModel.ExpandOnCreateUI = false; nbRows += AddCriteriaModelRows(componentQueryDeclarationModel, ExpandedContainer); }
int AddRows(ComponentQueryDeclarationModel componentQueryDeclarationModel, ExpandedContainer expandedContainer) { QueryContainer query = componentQueryDeclarationModel.Query; if (query?.RootGroup == null) { return(0); } return(AddGroupComponentRows(query, query.RootGroup, expandedContainer, componentQueryDeclarationModel)); }
public ComponentQuery(ComponentQueryDeclarationModel componentQueryDeclarationModel, Store store, Blackboard.RebuildCallback rebuildCallback) : base(componentQueryDeclarationModel, store, rebuildCallback) { name = "componentQuery"; capabilities |= Capabilities.Selectable | Capabilities.Droppable | Capabilities.Deletable; RegisterCallback <MouseDownEvent>(OnMouseDownEvent); this.AddManipulator(new SelectionDropper()); }
public void NestedIterationSystem_DifferentGroups_DifferentComponents([Values] CodeGenMode mode) { SetupTestGraph(mode, g => { TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil); TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil); // query1 - Position ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1"); query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None); IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero); // query2 - Rotation too ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2"); query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None); IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero); // update query 1 OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort); // nested update query 2 var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero); var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel; Assert.That(forAllNode, Is.Not.Null); GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort); GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort); // set query1.translation = ... SetPropertyGroupNodeModel set = forAllStack.CreateStackedNode <SetPropertyGroupNodeModel>("set"); var member = new TypeMember(TypeHandle.Float, new List <string> { nameof(Translation.Value), nameof(Translation.Value.x) }); set.AddMember(member); IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == translationType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); ((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f; }, (manager, entityIndex, e) => { manager.AddComponentData(e, new Translation { Value = { x = entityIndex } }); manager.AddComponentData(e, new Rotation()); }, (manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f))); }
public void SendEventTest([Values] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, g => { ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1"); TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None); IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil); SendEventNodeModel set = onUpdateModel.CreateStackedNode <SendEventNodeModel>("set", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle); TypeHandle entityType = typeof(Entity).GenerateTypeHandle(Stencil); IVariableModel entityVar = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == entityType), Vector2.zero); GraphModel.CreateEdge(set.EntityPort, entityVar.OutputPort); var firstFieldInput = set.FieldInputs.First(); ((FloatConstantModel)set.InputConstantsById[firstFieldInput.UniqueId]).value = 2f; }, // Add translation to even entities EachEntity((manager, i, e) => { manager.AddComponent(e, typeof(Translation)); manager.World.CreateSystem <InitializationSystemGroup>(); }), (manager, entities) => { EventSystem <UnitTestEvent> eventSystem = manager.World.GetExistingSystem <EventSystem <UnitTestEvent> >(); Assert.That(eventSystem, Is.Not.Null); eventSystem.Update(); }, // OnUpdate should have added a buffer and one event EachEntity((manager, i, e) => { DynamicBuffer <UnitTestEvent> buffer = default; Assert.DoesNotThrow(() => buffer = manager.GetBuffer <UnitTestEvent>(e)); Assert.That(buffer.IsCreated, Is.True); Assert.That(buffer.Length, Is.EqualTo(1)); Assert.That(buffer[0].i, Is.EqualTo(2f)); }) ); }
internal static void ShowCriteria(ComponentQueryDeclarationModel query, string title, Vector2 position, Action <TypeHandle, TypeMember, BinaryOperatorKind> onComponentSelected) { var provider = (EcsSearcherDatabaseProvider)query.GraphModel.Stencil.GetSearcherDatabaseProvider(); var databases = provider.GetCriteriaSearcherDatabases(query); var criteriaAdapter = new SimpleSearcherAdapter(title); var searcher = new Searcher.Searcher(databases, criteriaAdapter); SearcherWindow.Show( EditorWindow.focusedWindow, searcher, item => OnItemSelected(item, onComponentSelected), position, null); }
int AddComponentRow(ComponentDefinition component, ComponentQueryDeclarationModel componentQueryDeclarationModel, ExpandedContainer expandedContainer) { Assert.IsNotNull(expandedContainer); expandedContainer.Add(new ComponentRow(componentQueryDeclarationModel, component, m_Stencil, Store, expandedContainer, OnDeleteComponent, OnUsageChanged)); return(1); }
protected override string IncludeTrackingSystemStateComponent(ComponentQueryDeclarationModel query, bool trackProcessed) { if (!m_QueryHasStateTracking.TryGetValue(query, out var stateComponentDesc)) { stateComponentDesc = new QueryStateComponent { Tracking = trackProcessed, ComponentName = $"{query.VariableName}Tracking" } } ; else { stateComponentDesc.Tracking |= trackProcessed; } m_QueryHasStateTracking[query] = stateComponentDesc; return(stateComponentDesc.ComponentName); }
void BuildCriteriaForComponentQuery(ComponentQueryDeclarationModel componentQueryDeclarationModel, ref int nbRows, Blackboard blackboard) { var componentQuery = blackboard != null ? new ComponentQuery(componentQueryDeclarationModel, Store, blackboard.Rebuild) : new ComponentQuery(componentQueryDeclarationModel, Store, _ => { }); var componentQueryDeclarationExpandableRow = new ExpandableRow("") { name = "componentsSectionComponentQuery", viewDataKey = "CriteriaSubSection/" + componentQueryDeclarationModel.GetId(), userData = $"CriteriaSubSection/{componentQueryDeclarationModel.name}", }; componentQueryDeclarationExpandableRow.Sortable = true; componentQueryDeclarationExpandableRow.ExpandableRowTitleContainer.AddManipulator(new Clickable(() => { })); componentQueryDeclarationExpandableRow.ExpandableRowTitleContainer.Add(componentQuery); componentQueryDeclarationExpandableRow.ExpandableRowTitleContainer.Add(new Label("(" + componentQueryDeclarationModel.CriteriaModels.Count + ")") { name = "count" }); componentQueryDeclarationExpandableRow.ExpandableRowTitleContainer.Add(new Button(() => { AddCriteriaModel(componentQueryDeclarationModel); }) { name = "addCriteriaButton", text = "+" }); var rowName = $"{ComponentQueriesRow.BlackboardEcsProviderTypeName}/{GetType().Name}/{componentQueryDeclarationModel}"; componentQueryDeclarationExpandableRow.OnExpanded += e => Store.GetState().EditorDataModel?.ExpandBlackboardRowsUponCreation(new[] { rowName }, e); State state = blackboard?.Store.GetState(); if (state != null && state.EditorDataModel.ShouldExpandBlackboardRowUponCreation(rowName)) { componentQueryDeclarationExpandableRow.Expanded = true; } ExpandedContainer.Add(componentQueryDeclarationExpandableRow); blackboard?.GraphVariables.Add(componentQuery); componentQueryDeclarationModel.ExpandOnCreateUI = false; nbRows += AddCriteriaModelRows(componentQueryDeclarationModel, componentQueryDeclarationExpandableRow.ExpandedContainer); }
public void AddComponentToQuery(ComponentQueryDeclarationModel componentQueryDeclarationModel) { SearcherService.ShowTypes( m_Stencil, Event.current.mousePosition, (t, i) => { var resolvedType = t.Resolve(m_Stencil); ComponentDefinitionFlags creationFlags = (typeof(ISharedComponentData).IsAssignableFrom(resolvedType)) ? ComponentDefinitionFlags.Shared : 0; Store.Dispatch(new AddComponentToQueryAction(componentQueryDeclarationModel, t, creationFlags)); }, GetComponentsSearcherFilter(m_Stencil) ); }
void AddCriterionToCriteriaModel(IGraphElementModel graphElementModel, CriteriaModel criteriaModel) { if (graphElementModel == null) { return; } ComponentQueryDeclarationModel queryDeclarationModel = null; switch (graphElementModel) { case ComponentQueryDeclarationModel criterionQueryDeclarationModel: queryDeclarationModel = criterionQueryDeclarationModel; break; case IIteratorStackModel iteratorStackModel: queryDeclarationModel = iteratorStackModel.ComponentQueryDeclarationModel; break; } if (queryDeclarationModel == null) { return; } Vector2 mousePosition = Event.current.mousePosition; EcsSearcherServices.ShowCriteria(queryDeclarationModel, k_AddCriterionTitle, mousePosition, (typeHandle, typeMember, operatorKind) => { m_Store.Dispatch(new AddCriterionAction((ICriteriaModelContainer)graphElementModel, criteriaModel, typeHandle, typeMember, operatorKind)); }); }
public override void OnConnection(IPortModel selfConnectedPortModel, IPortModel otherConnectedPortModel) { if (selfConnectedPortModel != null) { var output = selfConnectedPortModel.Direction == Direction.Input ? OutputPort.ConnectionPortModels.FirstOrDefault()?.NodeModel : otherConnectedPortModel?.NodeModel; if (selfConnectedPortModel.Direction == Direction.Input && selfConnectedPortModel.UniqueId == k_InputPortId) { ComponentQueryDeclarationModel = OnEntitiesEventBaseNodeModel.GetConnectedEntityQuery(otherConnectedPortModel); } if (output is ForAllEntitiesStackModel foreachStack) { foreachStack.OnConnection(foreachStack.InputPort, OutputPort); ((VSGraphModel)GraphModel).LastChanges.ChangedElements.Add(foreachStack); } } }
public void OneGroupIterationSystem_LocalVariable([Values] CodeGenMode mode) { SetupTestGraph(mode, g => { ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1"); TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None); IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); var localDeclaration = onUpdateModel.CreateFunctionVariableDeclaration("local", TypeHandle.Float); var local = GraphModel.CreateVariableNode(localDeclaration, Vector2.zero); var log = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); GraphModel.CreateEdge(log.GetParameterPorts().First(), local.OutputPort); }, (manager, entityIndex, e) => {}, (manager, entityIndex, e) => Assert.Pass()); }
public QuerySubSection(Stencil stencil, ComponentQueryDeclarationModel componentQueryDeclarationModel, Blackboard blackboard) : base("", graphElementModel: null, store: blackboard.Store, parentElement: null, rebuildCallback: null, canAcceptDrop: null) { name = "queriesSection"; userData = name; AddToClassList("subSection"); State state = blackboard.Store.GetState(); var componentQuery = new ComponentQuery(componentQueryDeclarationModel, Store, blackboard.Rebuild); Sortable = true; ExpandableRowTitleContainer.AddManipulator(new Clickable(() => {})); ExpandableRowTitleContainer.Add(componentQuery); ExpandableRowTitleContainer.Add(new Label($"({(componentQueryDeclarationModel.Query?.Components?.Count ?? 0)})") { name = "count" }); var rowName = $"{ComponentQueriesRow.BlackboardEcsProviderTypeName}/{GetType().Name}/{componentQueryDeclarationModel}"; OnExpanded += e => Store.GetState().EditorDataModel?.ExpandBlackboardRowsUponCreation(new[] { rowName }, e); if (state.EditorDataModel.ShouldExpandBlackboardRowUponCreation(rowName)) { Expanded = true; } ExpandedContainer.Add(new ComponentsSubSection(stencil, componentQueryDeclarationModel, blackboard)); ExpandedContainer.Add(new CriteriaSubSection(stencil, componentQueryDeclarationModel, blackboard)); blackboard.GraphVariables.Add(componentQuery); }
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); }
public void OneGroupIterationSystem_ReadOnly([Values] CodeGenMode mode) { SetupTestGraph(mode, g => { ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1"); TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil); TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None); query.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None); IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); var log = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == translationType), Vector2.zero); GraphModel.CreateEdge(log.GetParameterPorts().First(), posComponent.OutputPort); }, (manager, entityIndex, e) => manager.AddComponents(e, new ComponentTypes(ComponentType.ReadWrite <Translation>(), ComponentType.ReadWrite <Rotation>())), (manager, entityIndex, e) => Assert.Pass()); }
public void NestedIterationSystem_DifferentGroups_NestedLocalVariable([Values] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, g => { TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil); TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil); // query1 - Position ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1"); query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None); IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero); // query2 - Rotation too ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2"); query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None); IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero); // update query 1 OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort); // nested update query 2 var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero); var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel; Assert.That(forAllNode, Is.Not.Null); GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort); GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort); var decl = forAllStack.CreateFunctionVariableDeclaration("x", TypeHandle.Int); // set query1.translation = ... SetVariableNodeModel set = forAllStack.CreateStackedNode <SetVariableNodeModel>("set"); IVariableModel posComponent = GraphModel.CreateVariableNode(decl, Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); }); }
int AddGroupComponentRows(QueryContainer query, QueryGroup queryRootGroup, ExpandedContainer expandedContainer, ComponentQueryDeclarationModel componentQueryDeclarationModel) { int nbRows = 0; foreach (QueryGroup subGroup in query.GetSubGroups(queryRootGroup)) { nbRows += AddGroupComponentRows(query, subGroup, expandedContainer, componentQueryDeclarationModel); } foreach (QueryComponent component in query.GetComponentsInQuery(queryRootGroup)) { nbRows += AddComponentRow(component.Component, componentQueryDeclarationModel, expandedContainer); } return(nbRows); }
public ComponentRow(ComponentQueryDeclarationModel componentQueryDeclarationModel, ComponentDefinition component, Stencil stencil, Store store, ExpandedContainer parentElement, Action <EventBase> onDeleteComponent, EventCallback <ChangeEvent <bool> > onUsageChanged) : base(string.Empty, componentQueryDeclarationModel, store, parentElement, null, null) { Component = component; m_Stencil = stencil; ClearClassList(); AddToClassList("componentRow"); var fieldViewContainerTooltip = new StringBuilder(); var fields = Component.TypeHandle.Resolve(stencil).GetFields(); int nbFields = fields.Length; if (nbFields > 0) { int i = 0; foreach (var field in fields) { var fieldView = new VisualElement { name = "fieldView" }; var fieldName = field.Name + ": "; var fieldTypeName = field.FieldType.Name; fieldView.Add(new Label(fieldName)); fieldView.Add(new Label(fieldTypeName)); fieldViewContainerTooltip.Append(fieldName + fieldTypeName); i++; if (i < nbFields) { fieldViewContainerTooltip.Append('\n'); } ExpandedContainer.Add(fieldView); } } else { ExpandedButton.style.display = DisplayStyle.None; } var deleteComponentButton = new Button { name = "deleteComponentIcon" }; deleteComponentButton.clickable.clickedWithEventInfo += onDeleteComponent; ExpandableRowTitleContainer.Insert(0, deleteComponentButton); var componentContainer = new VisualElement { name = "rowFieldContainer" }; string componentNamespace = component.TypeHandle.GetMetadata(stencil).Namespace; string componentName = component.TypeHandle.ToTypeSyntax(stencil).ToString().Replace(componentNamespace + ".", ""); userData = $"{GraphElementModel}/{componentName}"; var rowPillContainer = new VisualElement { name = "rowPillContainer" }; var componentPill = new ComponentPill(component, componentName, fieldViewContainerTooltip.ToString()); rowPillContainer.Add(componentPill); componentContainer.Add(rowPillContainer); var usageField = new Toggle("Subtract") { value = component.Subtract }; usageField.AddToClassList("usage"); usageField.RegisterValueChangedCallback(onUsageChanged); componentContainer.Add(usageField); ExpandableRowTitleContainer.Add(componentContainer); capabilities |= Capabilities.Selectable | Capabilities.Deletable; var expandedRowName = $"{ComponentQueriesRow.BlackboardEcsProviderTypeName}/{typeof(ComponentsSubSection).Name}/{componentQueryDeclarationModel}/{componentName}"; if (store.GetState().EditorDataModel.ShouldExpandBlackboardRowUponCreation(expandedRowName)) { Expanded = true; } OnExpanded = e => Store.GetState().EditorDataModel?.ExpandBlackboardRowsUponCreation(new[] { expandedRowName }, e); this.AddManipulator(new ContextualMenuManipulator(OnContextualMenuEvent)); }
static void UpdateComponentQuery(State previousState, ComponentQueryDeclarationModel queryDeclarationModel, IComponentQueryAction queryAction) { Assert.False(queryAction is MoveComponentInQueryAction, $"Use {nameof(UpdateComponentQueryInternal)} instead when moving components"); UpdateComponentQueryInternal(previousState, queryDeclarationModel, queryAction, -1, -1); }
protected virtual string IncludeTrackingSystemStateComponent(ComponentQueryDeclarationModel query, bool trackProcessed) { return(Parent.IncludeTrackingSystemStateComponent(query, trackProcessed)); }