private ControllerValue(AnimatorControllerPlayable playable, int paramId, ValueAccessor <T> accessor)
{
this.playable = playable;
this.paramId = paramId;
this.accessor = accessor;
paramCache = null;
}
public AdsErrorCode TryRead(out object[] values, out AdsErrorCode[] returnCodes)
{
IList <SumDataEntity> sumEntities = this.CreateSumEntityInfos();
base.innerCommand = new SumRead(base.connection, sumEntities, TwinCAT.Ads.SumCommand.SumCommand.SumAccessMode.IndexGroupIndexOffset);
values = null;
IList <byte[]> readData = null;
AdsErrorCode code = base.innerCommand.TryReadRaw(out readData, out returnCodes);
if (code == AdsErrorCode.NoError)
{
values = new object[sumEntities.Count];
IList <Symbol> unwrappedSymbols = base.UnwrappedSymbols;
ValueAccessor valueAccessor = base.ValueAccessor;
for (int i = 0; i < base.symbols.Count; i++)
{
ISymbol symbol = base.symbols[i];
if (returnCodes[i] == AdsErrorCode.NoError)
{
values[i] = valueAccessor.ValueFactory.CreateValue(symbol, readData[i], 0, DateTime.UtcNow);
}
}
}
return(code);
}
/// <summary>
/// Constructs a new NdArray over an existing data block and optionally shapes it
/// </summary>
/// <param name="data">The data to wrap in a NdArray</param>
/// <param name="shape">The shape to view the array in</param>
public NdArray(IDataAccessor <T> data, Shape shape = null)
{
this.Shape = shape ?? new long[] { data.Length };
if (data.Length < this.Shape.Length)
{
throw new ArgumentOutOfRangeException("dimensionsizes", string.Format("The length of the data is {0} but the shape requires {1} elements", data.Length, shape.Length));
}
m_data = data;
Value = new ValueAccessor(this);
}
/// <summary>
/// Callback from WPF to tell us that one of the dependency properties has been changed.
/// For the dependency properties that are registered here, this method generates a ValueContainer from the property value
/// and then sets the ValueAccessor to contain the new value, if it is different than the IVA's current value.
/// </summary>
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.Property == VCProperty || e.Property == ValueAsObjectProperty || e.Property == ValueAsDoubleProperty || e.Property == ValueAsBooleanProperty || e.Property == ValueAsInt32Property || e.Property == ValueAsStringProperty)
{
ValueContainer newValueVC = new ValueContainer().SetFromObject(e.NewValue);
// we only pass the newValueVC back to the ValueAccessor if the OnPropertyChanged callback is not a direct result of logic in the NotifyValueHasBeenUpdated method
if (!inNotifyValueHasBeenUpdated)
{
if (!ValueAccessor.VC.IsEqualTo(newValueVC))
{
ValueAccessor.Set(newValueVC);
lastVC = newValueVC;
}
}
else if (!lastVC.IsEqualTo(newValueVC))
{
lastVC = newValueVC;
}
if (e.Property == VCProperty)
{
lastVC = newValueVC;
}
else if (e.Property == ValueAsObjectProperty)
{
lastValueAsObject = e.NewValue;
}
else if (e.Property == ValueAsDoubleProperty)
{
lastValueAsDouble = e.NewValue as double?;
}
else if (e.Property == ValueAsBooleanProperty)
{
lastValueAsBoolean = e.NewValue as bool?;
}
else if (e.Property == ValueAsInt32Property)
{
lastValueAsInt32 = e.NewValue as Int32?;
}
else if (e.Property == ValueAsStringProperty)
{
lastValueAsString = e.NewValue as String;
}
}
else
{
base.OnPropertyChanged(e);
}
}
private void OnEnable()
{
_initialized = false;
accessor = target as ValueAccessor;
Refresh();
if (_sourceMembers.Count > 0)
{
if (_sourceIndex >= _sourceMembers.Count)
{
_sourceIndex = 0;
}
_sourceIndex = Array.IndexOf(_sourceMemberNames, accessor.SourceMemberName);
_formatString = accessor.FormatString;
_initialized = true;
}
}
protected override ConvertResult <IValueAccessor> ConvertSupportedItem(ItemModel source)
{
var accessor = new ValueAccessor();
// First - get overriden Value Reader / Writer
accessor.ValueReader = GetValueReader(source);
accessor.ValueWriter = GetValueWriter(source);
// Than if no custom Value Reader is set - use JsonNode Reader
if (accessor.ValueReader == null)
{
accessor.ValueReader = new JsonNodeValueReader()
{
JPath = GetStringValue(source, JPathFieldName)
};
}
return(new ConvertResult <IValueAccessor>()
{
ConvertedValue = accessor, WasConverted = true
});
}
/// <summary>
/// Initializes the node.
/// </summary>
/// <param name="context">The parent.</param>
private void InitializeNode(object context)
{
var contextType = (context == null || context is Type ? context as Type : context.GetType());
if (_accessor == null || _accessor.RequiresRefresh(contextType))
{
_memberName = getText();
// clear cached member info if context type has changed (for example, when ASP.NET page is recompiled)
if (_accessor != null && _accessor.RequiresRefresh(contextType))
{
_accessor = null;
}
// initialize this node if necessary
if (contextType != null && _accessor == null)
{
// try to initialize node as ExpandoObject value
if (contextType == typeof(ExpandoObject))
{
_accessor = new ExpandoObjectValueAccessor(_memberName);
}
else if (contextType.IsEnum)
{
// try to initialize node as enum value first
try
{
_accessor = new EnumValueAccessor(Enum.Parse(contextType, _memberName, true));
}
catch (ArgumentException)
{
// ArgumentException will be thrown if specified member name is not a valid
// enum value for the context type. We should just ignore it and continue processing,
// because the specified member could be a property of a Type class (i.e. EnumType.FullName)
}
}
// then try to initialize node as property or field value
if (_accessor == null)
{
// check the context type first
_accessor = GetPropertyOrFieldAccessor(contextType, _memberName, DefaultBindingFlags);
// if not found, probe the Type type
if (_accessor == null && context is Type)
{
_accessor = GetPropertyOrFieldAccessor(typeof(Type), _memberName, DefaultBindingFlags);
}
}
}
// if there is still no match, try to initialize node as type accessor
if (_accessor == null)
{
try
{
_accessor = new TypeValueAccessor(TypeResolutionUtils.ResolveType(_memberName));
}
catch (TypeLoadException)
{
if (context == null)
{
throw new NullValueInNestedPathException("Cannot initialize property or field node '" +
_memberName +
"' because the specified context is null.");
}
throw new InvalidPropertyException(contextType, _memberName,
"'" + _memberName +
"' node cannot be resolved for the specified context [" +
context + "].");
}
}
}
}
/// <summary>
/// Internal helper for reading data from USD.
/// </summary>
/// <param name="attrName">The USD attribute name.</param>
/// <param name="csType">The C# type.</param>
/// <param name="csValue">The C# value to populate.</param>
/// <param name="usdTime">The time at which to sample key frames.</param>
/// <param name="prim">The USD prim from which to read data.</param>
/// <param name="memberInfo">The field/property providing serialization metadata.</param>
/// <param name="usdNamespace">The optional USD namespace at which values live.</param>
/// <param name="accessMap">A map of members to include when reading.</param>
/// <param name="mayVary">When not null, is populated with variability.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// Note that "success" in the return value does not indicate data was read, rather it
/// indicates that no unexpected states were encountered. E.g. calling ReadAttr on a field
/// with no value stored in USD will not return false, since that is not considered a failure
/// state.
/// </remarks>
bool ReadAttr(string attrName, Type csType, ref object csValue, pxr.UsdTimeCode usdTime,
pxr.UsdPrim prim, MemberInfo memberInfo,
HashSet <MemberInfo> accessMap, ref bool?mayVary,
string usdNamespace)
{
bool isNewPrimvar = csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Primvar <>); // This is true for Primvar type only
bool isPrimvar = Reflect.IsPrimvar(memberInfo) || isNewPrimvar; // This is true for VertexData + Primvar type...
string ns = IntrinsicTypeConverter.JoinNamespace(usdNamespace,
Reflect.GetNamespace(memberInfo));
// ----------------------------------------- //
// Dictionaries, read, early exit, recurse.
// ----------------------------------------- //
// If holding a dictionary, immediately recurse and write keys as attributes.
if (csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Dictionary <,>) &&
csType.GetGenericArguments()[0] == typeof(string))
{
Type genericTypeDef = csType.GetGenericArguments()[1].IsGenericType
? csType.GetGenericArguments()[1].GetGenericTypeDefinition()
: null;
isNewPrimvar = genericTypeDef == typeof(Primvar <>);
bool isRelationship = csType.GetGenericArguments()[1] == typeof(Relationship);
bool isConnection = genericTypeDef == typeof(Connectable <>);
// String dictionaries are unrolled directly into the object.
// So the namespace is either the incoming namespace or empty, meaning each string value in
// the dictionary becomes an attribute on the prim.
// Ensure there is always a namespace immediately around this member.
if (string.IsNullOrEmpty(Reflect.GetNamespace(memberInfo)))
{
ns = IntrinsicTypeConverter.JoinNamespace(ns, attrName);
usdNamespace = IntrinsicTypeConverter.JoinNamespace(usdNamespace, attrName);
}
// Unfortunately, the primvars prefixing logic must be replicated here so we can discover
// the dictionary member from USD.
if (isPrimvar || isNewPrimvar)
{
ns = IntrinsicTypeConverter.JoinNamespace("primvars", ns);
}
var dict = csValue as System.Collections.IDictionary;
ConstructorInfo ctor = (isNewPrimvar || isConnection || isRelationship)
? csType.GetGenericArguments()[1].GetConstructor(new Type[0])
: null;
dict.Clear();
foreach (var prop in prim.GetAuthoredPropertiesInNamespace(ns))
{
object value = null;
if (ctor != null)
{
value = ctor.Invoke(new object[0]);
}
// The recursive call will also discover that this is a primvar and any associated namespace.
if (ReadAttr(prop.GetBaseName(),
csType.GetGenericArguments()[1],
ref value,
usdTime,
prim,
memberInfo,
accessMap,
ref mayVary,
usdNamespace))
{
if (value != null)
{
dict.Add(prop.GetBaseName().ToString(), value);
}
}
}
return(true);
}
pxr.TfToken sdfAttrName = sm_tokenCache[ns, attrName];
// ----------------------------------------- //
// Relationship, read + early exit.
// ----------------------------------------- //
if (csType == typeof(Relationship))
{
// mayVary is explicitly not set here because it has accumulation semantics:
// mayVary = mayVary || false;
// Which is equivalent to the no-op:
// mayVary = mayVary;
pxr.UsdRelationship rel = null;
lock (m_stageLock) {
rel = prim.GetRelationship(sm_tokenCache[sdfAttrName]);
}
var relationship = new Relationship();
csValue = relationship;
if (rel == null || !rel.IsValid())
{
return(true);
}
pxr.SdfPathVector paths = rel.GetTargets();
string[] result = new string[paths.Count];
for (int i = 0; i < paths.Count; i++)
{
result[i] = paths[i].ToString();
}
relationship.targetPaths = result;
return(true);
}
// ----------------------------------------- //
// Connection Setup.
// ----------------------------------------- //
Connectable conn = null;
if (csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Connectable <>))
{
conn = csValue as Connectable;
if (conn != null)
{
// Since this is a Connectable<T>, the held value T is what's being read from USD,
// so replace csValue with the held T value itself. csValue must be restored before
// returning.
csValue = conn.GetValue();
// Same treatment for the type.
csType = conn.GetValueType();
}
}
// ----------------------------------------- //
// Primvar Setup.
// ----------------------------------------- //
ValueAccessor pvAccessor = null;
PrimvarBase pvBase = null;
if (isNewPrimvar)
{
pvAccessor = csValue as ValueAccessor;
pvBase = (PrimvarBase)csValue;
// Since this is a Primvar<T>, the held value T is what's being read from USD,
// so replace csVAlue with the held T value itself. csValue must be restored before
// returning.
csValue = pvAccessor.GetValue();
// Same treatment for the type.
csType = pvAccessor.GetValueType();
}
// ----------------------------------------- //
// Lookup Type Conversion Delegate.
// ----------------------------------------- //
UsdTypeBinding binding;
if (!sm_bindings.GetBinding(csType, out binding) &&
!csType.IsEnum &&
csType != typeof(object))
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
var sample = csValue as SampleBase;
if (csValue == null)
{
// This could attempt to automatically constuct the needed object, then nullable objects
// could be used instead to drive deserialization.
return(false);
}
else if (sample == null)
{
// In this case, csValue is not null, but also cannot be converted to SampleBase.
throw new ArgumentException("Type does not inherit from SampleBase: " + attrName);
}
Deserialize((SampleBase)csValue, prim, usdTime, accessMap, ref mayVary, usdNamespace: ns);
return(true);
}
// ----------------------------------------- //
// Prep to Read.
// ----------------------------------------- //
// Restore C# value to the actual property value.
if (conn != null)
{
csValue = conn;
}
else if (pvAccessor != null)
{
csValue = pvAccessor;
}
// Append "primvars:" namespace to primvars.
if (isPrimvar)
{
var joinedName = IntrinsicTypeConverter.JoinNamespace(ns, attrName);
sdfAttrName = sm_tokenCache["primvars", joinedName];
}
// Adjust time for variability.
pxr.SdfVariability variability = Reflect.GetVariability(memberInfo);
pxr.UsdTimeCode time = variability == pxr.SdfVariability.SdfVariabilityUniform
? kDefaultUsdTime
: usdTime;
// Allocate a temp VtValue.
pxr.VtValue vtValue = (pxr.VtValue)ArrayAllocator.MallocHandle(typeof(pxr.VtValue));
try
{
// ----------------------------------------- //
// Read Connected Paths.
// ----------------------------------------- //
if (conn != null)
{
// Connection paths cannot be animated, so mayVary is not affected.
var sources = new pxr.SdfPathVector();
if (prim.GetAttribute(sdfAttrName).GetConnections(sources))
{
if (sources.Count > 0)
{
conn.SetConnectedPath(sources[0].ToString());
}
}
}
// ----------------------------------------- //
// Read Associated Primvar Data.
// ----------------------------------------- //
// If this is a Primvar<T>, read the associated primvar metadata and indices.
if (pvBase != null)
{
UsdAttribute attr = null;
if (Reflect.IsFusedDisplayColor(memberInfo))
{
var gprim = new pxr.UsdGeomGprim(prim);
if (gprim)
{
attr = gprim.GetDisplayColorAttr();
}
}
else
{
attr = prim.GetAttribute(sdfAttrName);
}
if (attr)
{
var pv = new pxr.UsdGeomPrimvar(attr);
// ElementSize and Interpolation are not animatable, so they do not affect mayVary.
pvBase.elementSize = pv.GetElementSize();
pvBase.SetInterpolationToken(pv.GetInterpolation());
// Primvars can be indexed and indices are a first class attribute and may vary over time.
var indices = pv.GetIndicesAttr();
if (indices)
{
if (accessMap != null)
{
if (indices.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
indices.ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
indices.Get(vtValue, time);
if (!vtValue.IsEmpty())
{
var vtIntArray = pxr.UsdCs.VtValueToVtIntArray(vtValue);
pvBase.indices = IntrinsicTypeConverter.FromVtArray(vtIntArray);
}
}
}
}
// ----------------------------------------- //
// Read the value of csValue.
// ----------------------------------------- //
if (Reflect.IsMetadata(memberInfo))
{
vtValue = prim.GetMetadata(sdfAttrName);
// Metadata cannot vary over time.
}
else if (Reflect.IsCustomData(memberInfo))
{
vtValue = prim.GetCustomDataByKey(sdfAttrName);
// Custom data is metadata, which cannot vary over time.
}
else if (Reflect.IsFusedDisplayColor(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedDisplayColor(prim, time);
if (accessMap != null)
{
// Display color is actually two attributes, primvars:displayColor and
// primvars:displayOpacity.
var gprim = new pxr.UsdGeomGprim(prim);
if (gprim && gprim.GetDisplayColorAttr().ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
}
else if (Reflect.IsFusedTransform(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedTransform(prim, time);
if (accessMap != null)
{
// Transforms are complicated :/
var xformable = new pxr.UsdGeomXformable(prim);
if (xformable)
{
bool dummy;
var orderAttr = xformable.GetXformOpOrderAttr();
if (orderAttr)
{
if (orderAttr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
orderAttr.ValueMightBeTimeVarying())
{
mayVary |= true;
accessMap.Add(memberInfo);
}
else
{
foreach (var op in xformable.GetOrderedXformOps(out dummy))
{
var opAttr = op.GetAttr();
if (!opAttr)
{
continue;
}
if (opAttr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
opAttr.ValueMightBeTimeVarying())
{
mayVary |= true;
accessMap.Add(memberInfo);
break;
}
} // foreach
}
} // orderAttr
} // xformable
} // mayVary
}
else
{
if (accessMap != null)
{
var attr = prim.GetAttribute(sdfAttrName);
if (attr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
attr.ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
if (!prim.GetAttributeValue(sdfAttrName, vtValue, time))
{
// Object has no value, still considered success.
return(true);
}
}
if (vtValue.IsEmpty())
{
// Object has no value, still considered success.
return(true);
}
// ------------------------------------------ //
// Infer C# type from USD when Type == Object
// ------------------------------------------ //
if (csType == typeof(object))
{
// Blind object serialization needs special handling, since we won't know the C# type a priori.
// Instead, do a reverse lookup on the SdfTypeName and let USD dictate the C# type.
pxr.UsdAttribute attr = prim.GetAttribute(sdfAttrName);
if (attr != null && attr.IsValid())
{
// TODO: Assuming the reverse lookup is successful for the binding, the caller may be
// surprised by the result, since the USD <-> C# types are not 1-to-1. For example,
// a List<Vector2> may have been serialized, but Vector2[] may be read.
if (!sm_bindings.GetReverseBinding(attr.GetTypeName(), out binding))
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
// TODO: readback nested object declared as object -- maybe just disable this?
//Deserialize(ref csValue, prim, usdTime, usdNamespace: ns);
//return true;
return(false);
}
}
else
{
// TODO: Allow reading metadata declared as object in C#
return(false);
}
}
// ------------------------------------------ //
// Convert USD's VtValue -> Strong C# Type.
// ------------------------------------------ //
csValue = binding.toCsObject(vtValue);
// ------------------------------------------ //
// Restore csValue.
// ------------------------------------------ //
if (conn != null && csValue != null)
{
conn.SetValue(csValue);
csValue = conn;
}
if (pvAccessor != null)
{
pvAccessor.SetValue(csValue);
csValue = pvAccessor;
}
}
finally
{
// Would prefer RAII handle, but introduces garbage.
ArrayAllocator.FreeHandle(vtValue);
}
return(true);
}
public virtual T GetValue()
{
return(ValueAccessor.Invoke());
}
/// <summary>
/// Initializes the node.
/// </summary>
/// <param name="context">The parent.</param>
private void InitializeNode(object context)
{
var contextType = (context == null || context is Type ? context as Type : context.GetType());
if (_accessor == null || _accessor.RequiresRefresh(contextType))
{
_memberName = getText();
// clear cached member info if context type has changed (for example, when ASP.NET page is recompiled)
if (_accessor != null && _accessor.RequiresRefresh(contextType))
{
_accessor = null;
}
// initialize this node if necessary
if (contextType != null && _accessor == null)
{
// try to initialize node as ExpandoObject value
if (contextType == typeof(ExpandoObject))
{
_accessor = new ExpandoObjectValueAccessor(_memberName);
}
else if (contextType.IsEnum)
{
// try to initialize node as enum value first
try
{
_accessor = new EnumValueAccessor(Enum.Parse(contextType, _memberName, true));
}
catch (ArgumentException)
{
// ArgumentException will be thrown if specified member name is not a valid
// enum value for the context type. We should just ignore it and continue processing,
// because the specified member could be a property of a Type class (i.e. EnumType.FullName)
}
}
// then try to initialize node as property or field value
if (_accessor == null)
{
// check the context type first
_accessor = GetPropertyOrFieldAccessor(contextType, _memberName, DefaultBindingFlags);
// if not found, probe the Type type
if (_accessor == null && context is Type)
{
_accessor = GetPropertyOrFieldAccessor(typeof(Type), _memberName, DefaultBindingFlags);
}
}
}
// if there is still no match, try to initialize node as type accessor
if (_accessor == null)
{
try
{
_accessor = new TypeValueAccessor(TypeResolutionUtils.ResolveType(_memberName));
}
catch (TypeLoadException)
{
if (context == null)
{
throw new NullValueInNestedPathException("Cannot initialize property or field node '" +
_memberName +
"' because the specified context is null.");
}
throw new InvalidPropertyException(contextType, _memberName,
"'" + _memberName +
"' node cannot be resolved for the specified context [" +
context + "].");
}
}
}
}
public ConvertContext(int columnIndex, ValueAccessor accessor)
{
ColumnIndex = columnIndex;
Accessor = accessor;
}
public ConstantValueExpression(TValue value)
{
Value = value;
Accessor = new ValueAccessor(value);
}