// ----------------------------------------------------------------------------------------- //
// Private API
// ----------------------------------------------------------------------------------------- //
/// <remarks>
/// Converts an std::vector to an array, but why?
/// Swig's current implementation of std::vector returns references to private memory, which
/// means any value obtained from it is extremely unsafe and will cause C++ style memory errors
/// if used after the vector is disposed. For safety, our API should never return a raw vector.
/// </remarks>
private SdfPath[] VectorToArray(SdfPathVector vec)
{
var ret = new SdfPath[vec.Count];
vec.CopyTo(ret);
return(ret);
}
public UsdSkelTopology(SdfPathVector paths) : this(UsdCsPINVOKE.new_UsdSkelTopology__SWIG_3(SdfPathVector.getCPtr(paths)), true)
{
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public SdfPathVectorEnumerator(SdfPathVector collection)
{
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
public UsdStagePopulationMask(SdfPathVector paths) : this(UsdCsPINVOKE.new_UsdStagePopulationMask__SWIG_4(SdfPathVector.getCPtr(paths)), true)
{
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public SdfPathVector(SdfPathVector other) : this(UsdCsPINVOKE.new_SdfPathVector__SWIG_1(SdfPathVector.getCPtr(other)), true)
{
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetItems(SdfPathVector items, SdfListOpType type)
{
UsdCsPINVOKE.SdfPathListOp_SetItems(swigCPtr, SdfPathVector.getCPtr(items), (int)type);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetOrderedItems(SdfPathVector items)
{
UsdCsPINVOKE.SdfPathListOp_SetOrderedItems(swigCPtr, SdfPathVector.getCPtr(items));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public void ComputeAttributeConnectionPaths(SdfPath attributePath, SdfPathVector paths, bool localOnly, SdfSpecHandle stopProperty, bool includeStopProperty, SdfPathVector deletedPaths, SWIGTYPE_p_PcpErrorVector allErrors)
{
UsdCsPINVOKE.PcpCache_ComputeAttributeConnectionPaths(swigCPtr, SdfPath.getCPtr(attributePath), SdfPathVector.getCPtr(paths), localOnly, SdfSpecHandle.getCPtr(stopProperty), includeStopProperty, SdfPathVector.getCPtr(deletedPaths), SWIGTYPE_p_PcpErrorVector.getCPtr(allErrors));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public void ComputeRelationshipTargetPaths(SdfPath relationshipPath, SdfPathVector paths, bool localOnly, SdfSpecHandle stopProperty, bool includeStopProperty, SWIGTYPE_p_PcpErrorVector allErrors)
{
UsdCsPINVOKE.PcpCache_ComputeRelationshipTargetPaths(swigCPtr, SdfPath.getCPtr(relationshipPath), SdfPathVector.getCPtr(paths), localOnly, SdfSpecHandle.getCPtr(stopProperty), includeStopProperty, SWIGTYPE_p_PcpErrorVector.getCPtr(allErrors));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetRange(int index, SdfPathVector values)
{
UsdCsPINVOKE.SdfPathVector_SetRange(swigCPtr, index, SdfPathVector.getCPtr(values));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
}
public bool SetTargets(SdfPathVector targets)
{
bool ret = UsdCsPINVOKE.UsdGeomCollectionAPI_SetTargets(swigCPtr, SdfPathVector.getCPtr(targets));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool ReplaceOperations(SdfListOpType op, uint index, uint n, SdfPathVector newItems)
{
bool ret = UsdCsPINVOKE.SdfPathListOp_ReplaceOperations(swigCPtr, (int)op, index, n, SdfPathVector.getCPtr(newItems));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static SdfPathVector GetConciseRelativePaths(SdfPathVector paths)
{
SdfPathVector ret = new SdfPathVector(UsdCsPINVOKE.SdfPath_GetConciseRelativePaths(SdfPathVector.getCPtr(paths)), true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static bool GetRawConnectedSourcePaths(UsdShadeOutput output, SdfPathVector sourcePaths)
{
bool ret = UsdCsPINVOKE.UsdShadeConnectableAPI_GetRawConnectedSourcePaths__SWIG_2(UsdShadeOutput.getCPtr(output), SdfPathVector.getCPtr(sourcePaths));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetConnections(SdfPathVector sources)
{
bool ret = UsdCsPINVOKE.UsdAttribute_SetConnections(swigCPtr, SdfPathVector.getCPtr(sources));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static SdfPathListOp CreateExplicit(SdfPathVector explicitItems)
{
SdfPathListOp ret = new SdfPathListOp(UsdCsPINVOKE.SdfPathListOp_CreateExplicit__SWIG_0(SdfPathVector.getCPtr(explicitItems)), true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
/// <summary>
/// At each path, reads the given sample type from t he USD Stage.
/// </summary>
/// <typeparam name="T">
/// A type which inherits from SampleBase, adorned with a UsdSchemaAttribute.
/// </typeparam>
/// <returns>
/// Returns a collection which will read each prim found and return the requested SampleBase
/// object type.
/// </returns>
public SampleCollection <T> ReadAll <T>(SdfPath[] paths) where T : SampleBase, new()
{
var vec = new SdfPathVector();
foreach (SdfPath path in paths)
{
vec.Add(path);
}
return(new SampleCollection <T>(this, vec));
}
public SdfPathVector GetPathsToPrimsWithRelocates()
{
SdfPathVector ret = new SdfPathVector(UsdCsPINVOKE.PcpLayerStack_GetPathsToPrimsWithRelocates(swigCPtr), false);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static SdfPathListOp Create(SdfPathVector prependedItems)
{
SdfPathListOp ret = new SdfPathListOp(UsdCsPINVOKE.SdfPathListOp_Create__SWIG_2(SdfPathVector.getCPtr(prependedItems)), true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static UsdGeomCollectionAPI Create(UsdPrim prim, TfToken name, SdfPathVector targets)
{
UsdGeomCollectionAPI ret = new UsdGeomCollectionAPI(UsdCsPINVOKE.UsdGeomCollectionAPI_Create__SWIG_2(UsdPrim.getCPtr(prim), TfToken.getCPtr(name), SdfPathVector.getCPtr(targets)), true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static bool GetRawConnectedSourcePaths(UsdProperty shadingProp, SdfPathVector sourcePaths)
{
bool ret = UsdCsPINVOKE.UsdShadeConnectableAPI_GetRawConnectedSourcePaths__SWIG_0(UsdProperty.getCPtr(shadingProp), SdfPathVector.getCPtr(sourcePaths));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetInherits(SdfPathVector items)
{
bool ret = UsdCsPINVOKE.UsdInherits_SetInherits(swigCPtr, SdfPathVector.getCPtr(items));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetBindingTargets(SdfPathVector bindings)
{
bool ret = UsdCsPINVOKE.UsdGeomFaceSetAPI_SetBindingTargets(swigCPtr, SdfPathVector.getCPtr(bindings));
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public SdfPathVector GetRange(int index, int count)
{
global::System.IntPtr cPtr = UsdCsPINVOKE.SdfPathVector_GetRange(swigCPtr, index, count);
SdfPathVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SdfPathVector(cPtr, true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static SdfPathVector Repeat(SdfPath value, int count)
{
global::System.IntPtr cPtr = UsdCsPINVOKE.SdfPathVector_Repeat(SdfPath.getCPtr(value), count);
SdfPathVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SdfPathVector(cPtr, true);
if (UsdCsPINVOKE.SWIGPendingException.Pending)
{
throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public SampleCollection(Scene scene, SdfPathVector paths)
{
m_paths = new SdfPath[paths.Count];
paths.CopyTo(m_paths);
m_scene = scene;
}
public SdfPathVector GetAllDirectInherits()
{
SdfPathVector ret = new SdfPathVector(UsdCsPINVOKE.UsdInherits_GetAllDirectInherits(swigCPtr), true);
return(ret);
}
public SdfPathVector GetPathsToPrimsWithRelocates()
{
SdfPathVector ret = new SdfPathVector(UsdCsPINVOKE.PcpLayerStackPtr_GetPathsToPrimsWithRelocates(swigCPtr), false);
return(ret);
}
public void GetAllTargetPathsRecursively(SdfPathVector result)
{
UsdCsPINVOKE.SdfPathAncestorsRange_iterator_GetAllTargetPathsRecursively(swigCPtr, SdfPathVector.getCPtr(result));
}
public void GetPrefixes(SdfPathVector prefixes)
{
UsdCsPINVOKE.SdfPathAncestorsRange_iterator_GetPrefixes__SWIG_1(swigCPtr, SdfPathVector.getCPtr(prefixes));
}
