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