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));
}
