public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property.propertyType == SerializedPropertyType.String)
{
if (_genericType == null)
{
_genericType = this.GetGenericType();
}
if (_attribute == null)
{
_attribute = (VariantNodeObjectAttribute)attribute;
}
var nodeObject = (INodeDataBuilder)property.GetSiblingFieldValue(_attribute.NodeObjectFieldName);
if (!Equals(nodeObject, _nodeObject))
{
var readerType = typeof(BlobVariantReader <>).MakeGenericType(_genericType);
var rwType = typeof(BlobVariantReaderAndWriter <>).MakeGenericType(_genericType);
_nodeObject = nodeObject;
_options = nodeObject == null
? new string[0]
: VirtualMachine.GetNodeType(nodeObject.NodeId)
.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(fi => fi.FieldType == _genericType || fi.FieldType == readerType || fi.FieldType == rwType)
.Select(fi => fi.Name)
.ToArray()
;
}
property.PopupFunc()(position, label.text, _options);
}
else
{
EditorGUI.PropertyField(position, property, label, true);
}
}
internal static IEnumerable <string> GetReadableFieldName <T>([CanBeNull] INodeDataBuilder builder)
where T : unmanaged
{
if (builder == null)
{
return(Enumerable.Empty <string>());
}
return(GetReadableFieldName <T>(VirtualMachine.GetNodeType(builder.NodeId)));
}
public void TestCreateList()
{
NodeDataListBuilder builder = Substitute.ForPartsOf <NodeDataListBuilder>(typeof(NodeDataClass));
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
FieldInfo iField = typeof(NodeDataClass).GetField("i", flags);
FieldInfo jField = typeof(NodeDataClass).GetField("j", flags);
FieldInfo kField = typeof(NodeDataClass).GetField("k", flags);
PropertyInfo xProperty = typeof(NodeDataClass).GetProperty("X", flags);
PropertyInfo yProperty = typeof(NodeDataClass).GetProperty("Y", flags);
PropertyInfo zProperty = typeof(NodeDataClass).GetProperty("Z", flags);
Assert.NotNull(iField);
Assert.NotNull(jField);
Assert.NotNull(kField);
Assert.NotNull(xProperty);
Assert.NotNull(yProperty);
Assert.NotNull(zProperty);
INodeDataBuilder builder1 = Substitute.For <INodeDataBuilder>();
INodeDataBuilder builder2 = Substitute.For <INodeDataBuilder>();
INodeDataBuilder builder3 = Substitute.For <INodeDataBuilder>();
INodeDataBuilder builder4 = Substitute.For <INodeDataBuilder>();
builder.WhenForAnyArgs(x => x.CreateFieldBuilder(null, null, null)).DoNotCallBase();
builder.CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <FieldWrapper>(x => x.MemberInfo == iField), DefaultValueParseMap.Instance).Returns(builder1);
builder.CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <FieldWrapper>(x => x.MemberInfo == jField), DefaultValueParseMap.Instance).Returns(builder2);
builder.CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <PropertyWrapper>(x => x.MemberInfo == xProperty), DefaultValueParseMap.Instance).Returns(builder3);
builder.CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <PropertyWrapper>(x => x.MemberInfo == yProperty), DefaultValueParseMap.Instance).Returns(builder4);
INodeDataField field1 = Substitute.For <INodeDataField>();
INodeDataField field2 = Substitute.For <INodeDataField>();
INodeDataField field3 = Substitute.For <INodeDataField>();
INodeDataField field4 = Substitute.For <INodeDataField>();
builder1.CreateNodeDataField().Returns(field1);
builder2.CreateNodeDataField().Returns(field2);
builder3.CreateNodeDataField().Returns(field3);
builder4.CreateNodeDataField().Returns(field4);
Assert.IsType <NodeDataList>(builder.CreateList());
builder.Received().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <FieldWrapper>(x => x.MemberInfo == iField), DefaultValueParseMap.Instance);
builder.Received().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <FieldWrapper>(x => x.MemberInfo == jField), DefaultValueParseMap.Instance);
builder.DidNotReceive().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <FieldWrapper>(x => x.MemberInfo == kField), Arg.Any <IValueParseMap>());
builder.Received().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <PropertyWrapper>(x => x.MemberInfo == xProperty), DefaultValueParseMap.Instance);
builder.Received().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <PropertyWrapper>(x => x.MemberInfo == yProperty), DefaultValueParseMap.Instance);
builder.DidNotReceive().CreateFieldBuilder(Arg.Any <NodeData>(), Arg.Is <PropertyWrapper>(x => x.MemberInfo == zProperty), Arg.Any <IValueParseMap>());
builder1.Received().CreateNodeDataField();
builder2.Received().CreateNodeDataField();
builder3.Received().CreateNodeDataField();
builder4.Received().CreateNodeDataField();
}
public static unsafe void Allocate <T>(
this VariableProperty <T> variable
, ref BlobBuilder builder
, void *blobVariablePtr
, INodeDataBuilder self
, ITreeNode <INodeDataBuilder>[] tree
) where T : struct
{
variable.Allocate(ref builder, ref UnsafeUtilityEx.AsRef <BlobVariable <T> >(blobVariablePtr), self, tree);
}
public static unsafe void Allocate <T>(
this VariableProperty <T> variable
, ref BlobBuilder builder
, void *blobVariablePtr
, [NotNull] INodeDataBuilder self
, [NotNull] ITreeNode <INodeDataBuilder>[] tree
) where T : unmanaged
{
variable.Allocate(ref builder, ref UnsafeUtility.AsRef <BlobVariable <T> >(blobVariablePtr), self, tree);
}
public virtual NodeDataList CreateList()
{
List <INodeDataField> builtFields = new List <INodeDataField>();
IValueParseMap parseMap = DefaultValueParseMap.Instance;
foreach (FieldInfo field in type.GetFields(FIELD_BINDING_FLAGS))
{
NodeData nodeData = (NodeData)field.GetCustomAttributes(typeof(NodeData), true).FirstOrDefault();
if (nodeData == null)
{
continue;
}
IFieldWrapper fieldWrapper = new FieldWrapper(field);
INodeDataBuilder builder = CreateFieldBuilder(nodeData, fieldWrapper, parseMap);
builtFields.Add(builder.CreateNodeDataField());
}
foreach (PropertyInfo property in type.GetProperties(FIELD_BINDING_FLAGS))
{
NodeData nodeData = (NodeData)property.GetCustomAttributes(typeof(NodeData), true).FirstOrDefault();
if (nodeData == null)
{
continue;
}
IFieldWrapper fieldWrapper = new PropertyWrapper(property);
INodeDataBuilder builder = CreateFieldBuilder(nodeData, fieldWrapper, parseMap);
builtFields.Add(builder.CreateNodeDataField());
}
return(new NodeDataList(builtFields.ToArray()));
}
protected virtual void AllocateData(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
}
public virtual void Allocate(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, [NotNull] INodeDataBuilder self, [NotNull] ITreeNode <INodeDataBuilder>[] tree)
{
blobVariable.VariableId = VariablePropertyTypeId;
AllocateData(ref builder, ref blobVariable, self, tree);
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariantWriter <T> blobVariant, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
return(Writer.Allocate(ref builder, ref blobVariant, self, tree));
}
public override void Allocate(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
var index = Array.FindIndex(tree, node => ReferenceEquals(node.Value, NodeObject));
if (!NodeObject || index < 0)
{
Debug.LogError($"Invalid `NodeObject` {NodeObject}", (UnityEngine.Object)self);
throw new ArgumentException();
}
var nodeType = VirtualMachine.GetNodeType(NodeObject.NodeId);
if (string.IsNullOrEmpty(ValueFieldName) && nodeType == typeof(T))
{
builder.Allocate(ref blobVariable, new DynamicNodeRefData {
Index = index, Offset = 0
});
return;
}
var fieldInfo = nodeType.GetField(ValueFieldName, FIELD_BINDING_FLAGS);
if (fieldInfo == null)
{
Debug.LogError($"Invalid `ValueFieldName` {ValueFieldName}", (UnityEngine.Object)self);
throw new ArgumentException();
}
var fieldOffset = Marshal.OffsetOf(nodeType, ValueFieldName).ToInt32();
builder.Allocate(ref blobVariable, new DynamicNodeRefData {
Index = index, Offset = fieldOffset
});
var fieldType = fieldInfo.FieldType;
if (fieldType == typeof(T))
{
blobVariable.VariableId = AccessRuntimeData ? _ID_RUNTIME_NODE : _ID_DEFAULT_NODE;
}
else if (fieldType == typeof(BlobVariable <T>))
{
blobVariable.VariableId = AccessRuntimeData ? _ID_RUNTIME_NODE_VARIABLE : _ID_DEFAULT_NODE_VARIABLE;
}
else
{
Debug.LogError($"Invalid type of `ValueFieldName` {ValueFieldName} {fieldType}", (UnityEngine.Object)self);
throw new ArgumentException();
}
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariant blobVariant, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
blobVariant.VariantId = GuidHashCode(GUID);
return(builder.Allocate(ref blobVariant, _port));
}
protected override void AllocateData(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
var data = GetTypeHashAndFieldOffset(ComponentValueName);
if (data.Type != typeof(T) || data.Hash == 0)
{
Debug.LogError($"ComponentVariable({ComponentValueName}) is not valid, fallback to ConstantValue", (UnityEngine.Object)self);
throw new ArgumentException();
}
if (CopyToLocalNode)
{
builder.Allocate(ref blobVariable, new CopyToLocalComponentData {
StableHash = data.Hash, Offset = data.Offset, LocalValue = default
});
}
else
{
builder.Allocate(ref blobVariable, new DynamicComponentData {
StableHash = data.Hash, Offset = data.Offset
});
}
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariant blobVariant, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
blobVariant.VariantId = GuidHashCode(GUID);
var data = GetTypeHashAndFieldOffset(ComponentValueName);
if (data.Type != typeof(T) || data.Hash == 0)
{
Debug.LogError($"{nameof(ComponentVariant)}({ComponentValueName}) is not valid, fallback to ConstantValue", (UnityEngine.Object)self);
throw new ArgumentException();
}
return(builder.Allocate(ref blobVariant, new DynamicComponentData {
StableHash = data.Hash, Offset = data.Offset
}));
}
protected override void AllocateData(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
var type = ScriptableObject.GetType();
FieldInfo fieldInfo = null;
PropertyInfo propertyInfo = null;
if (ScriptableObject != null)
{
fieldInfo = type.GetField(ScriptableObjectValueName, FIELD_BINDING_FLAGS);
}
if (fieldInfo == null)
{
propertyInfo = type.GetProperty(ScriptableObjectValueName, FIELD_BINDING_FLAGS);
}
if ((fieldInfo == null || fieldInfo.FieldType != typeof(T)) &&
(propertyInfo == null || !propertyInfo.CanRead || propertyInfo.PropertyType != typeof(T)))
{
Debug.LogError($"{ScriptableObject.name}.{ScriptableObjectValueName} is not valid");
throw new ArgumentException();
}
var value = fieldInfo?.GetValue(ScriptableObject) ?? propertyInfo?.GetValue(ScriptableObject);
builder.Allocate(ref blobVariable, (T)value);
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariant blobVariant, INodeDataBuilder self,
ITreeNode <INodeDataBuilder>[] tree)
{
return(NodeVariant.Allocate <T>(ref builder, ref blobVariant, self, tree, NodeObject, ValueFieldName));
}
protected override void AllocateData(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
builder.Allocate(ref blobVariable, CustomValue);
}
public BTVirtualDecorator(INodeDataBuilder child) => _child = new BTVirtualRealSelf(child);
public BTVirtualRealSelf(INodeDataBuilder self) => _self = self;
public void BuildImpl(BlobBuilder blobBuilder, ref RepeatForeverNode data, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] builders)
{
data.BreakStates = BreakStates;
}
public static BlobAssetReference <NodeBlob> ToBlob([NotNull] this INodeDataBuilder root, Allocator allocator = Allocator.Persistent)
{
return(root.Flatten(builder => builder.Children, builder => builder.Self).ToArray().ToBlob(allocator));
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariant blobVariant, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
blobVariant.VariantId = GuidHashCode(GUID);
var type = ScriptableObject.GetType();
FieldInfo fieldInfo = null;
PropertyInfo propertyInfo = null;
if (ScriptableObject != null)
{
fieldInfo = type.GetField(ScriptableObjectValueName, BindingFlags.Instance | BindingFlags.Public);
}
if (fieldInfo == null)
{
propertyInfo = type.GetProperty(ScriptableObjectValueName, BindingFlags.Instance | BindingFlags.Public);
}
if ((fieldInfo == null || fieldInfo.FieldType != typeof(T)) &&
(propertyInfo == null || !propertyInfo.CanRead || propertyInfo.PropertyType != typeof(T)))
{
Debug.LogError($"{ScriptableObject.name}.{ScriptableObjectValueName} is not valid");
throw new ArgumentException();
}
var value = fieldInfo?.GetValue(ScriptableObject) ?? propertyInfo?.GetValue(ScriptableObject);
return(builder.Allocate(ref blobVariant, (T)value));
}
public IntPtr Allocate(ref BlobBuilder builder, ref BlobVariant blobVariant, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
blobVariant.VariantId = GuidHashCode(ComponentVariant.GUID);
return(builder.Allocate(ref blobVariant, new ComponentVariant.DynamicComponentData {
StableHash = _stableHash, Offset = _offset
}));
}
protected override void AllocateData(ref BlobBuilder builder, ref BlobVariable <T> blobVariable, INodeDataBuilder self, ITreeNode <INodeDataBuilder>[] tree)
{
if (_useRef)
{
builder.Allocate(ref blobVariable, new ComponentVariableProperty <T> .DynamicComponentData {
StableHash = _stableHash, Offset = _offset
});
}
else
{
builder.Allocate(ref blobVariable, new ComponentVariableProperty <T> .CopyToLocalComponentData {
StableHash = _stableHash, Offset = _offset, LocalValue = default
});
