//-*****************************************************************************
void ProcessNuPatch( INuPatch &patch, ProcArgs &args )
{
INuPatchSchema &ps = patch.getSchema();
TimeSamplingPtr ts = ps.getTimeSampling();
SampleTimeSet sampleTimes;
GetRelevantSampleTimes( args, ts, ps.getNumSamples(), sampleTimes );
//trim curves are described outside the motion blocks
if ( ps.hasTrimCurve() )
{
//get the current time sample independent of any shutter values
INuPatchSchema::Sample sample = ps.getValue(
ISampleSelector( args.frame / args.fps ) );
RiTrimCurve( sample.getTrimNumCurves()->size(), //numloops
(RtInt*) sample.getTrimNumCurves()->get(),
(RtInt*) sample.getTrimOrders()->get(),
(RtFloat*) sample.getTrimKnots()->get(),
(RtFloat*) sample.getTrimMins()->get(),
(RtFloat*) sample.getTrimMaxes()->get(),
(RtInt*) sample.getTrimNumVertices()->get(),
(RtFloat*) sample.getTrimU()->get(),
(RtFloat*) sample.getTrimV()->get(),
(RtFloat*) sample.getTrimW()->get() );
}
bool multiSample = sampleTimes.size() > 1;
if ( multiSample ) { WriteMotionBegin( args, sampleTimes ); }
for ( SampleTimeSet::iterator iter = sampleTimes.begin();
iter != sampleTimes.end(); ++iter )
{
ISampleSelector sampleSelector( *iter );
INuPatchSchema::Sample sample = ps.getValue( sampleSelector );
ParamListBuilder paramListBuilder;
//build this here so that it's still in scope when RiNuPatchV is
//called.
std::vector<RtFloat> pwValues;
if ( sample.getPositionWeights() )
{
if ( sample.getPositionWeights()->size() == sample.getPositions()->size() )
{
//need to combine P with weight form Pw
pwValues.reserve( sample.getPositions()->size() * 4 );
const float32_t * pStart = reinterpret_cast<const float32_t * >(
sample.getPositions()->get() );
const float32_t * wStart = reinterpret_cast<const float32_t * >(
sample.getPositionWeights()->get() );
for ( size_t i = 0, e = sample.getPositionWeights()->size();
i < e; ++i )
{
pwValues.push_back( pStart[i*3] );
pwValues.push_back( pStart[i*3+1] );
pwValues.push_back( pStart[i*3+2] );
pwValues.push_back( wStart[i] );
}
paramListBuilder.add( "Pw", (RtPointer) &pwValues[0] );
}
}
if ( pwValues.empty() )
{
//no Pw so go straight with P
paramListBuilder.add( "P",
(RtPointer)sample.getPositions()->get() );
}
ICompoundProperty arbGeomParams = ps.getArbGeomParams();
AddArbitraryGeomParams( arbGeomParams,
sampleSelector, paramListBuilder );
//For now, use the last knot value for umin and umax as it's
//not described in the alembic data
RiNuPatchV(
sample.getNumU(),
sample.getUOrder(),
(RtFloat *) sample.getUKnot()->get(),
0.0, //umin
sample.getUKnot()->get()[sample.getUKnot()->size()-1],//umax
sample.getNumV(),
sample.getVOrder(),
(RtFloat *) sample.getVKnot()->get(),
0.0, //vmin
sample.getVKnot()->get()[sample.getVKnot()->size()-1], //vmax
paramListBuilder.n(),
paramListBuilder.nms(),
paramListBuilder.vals() );
}
if ( multiSample ) { RiMotionEnd(); }
}
//-*****************************************************************************
// a recursive function that reads all inputs and write to the given oObject
// node if there's no gap in the frame range for animated nodes
//
void visitObjects(std::vector< IObject > & iObjects, OObject & oParentObj)
{
OObject outObj;
const AbcA::ObjectHeader & header = iObjects[0].getHeader();
// there are a number of things that needs to be checked for each node
// to make sure they can be properly stitched together
//
// for xform node:
// locator or normal xform node
// if an xform node, numOps and type of ops match
// static or no, and if not, timesampling type matches
// if sampled, timesampling type should match
// if sampled, no frame gaps
//
if (IXform::matches(header))
{
OXformSchema oSchema;
init< IXform,
IXformSchema,
OXform,
OXformSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
ICompoundPropertyVec iCompoundProps;
iCompoundProps.reserve(iObjects.size());
ICompoundProperty cp = iObjects[0].getProperties();
iCompoundProps.push_back(cp);
bool isLocator = cp.getPropertyHeader("locator")?true:false;
for (size_t i = 1; i < iObjects.size(); i++)
{
ICompoundProperty cp = iObjects[i].getProperties();
iCompoundProps.push_back(cp);
}
// stitch the operations if this is an xform node
for (size_t i = 0; i < iObjects.size(); i++)
{
IXformSchema iSchema =
IXform(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
XformSample samp = iSchema.getValue(reqIdx);
oSchema.set(samp);
}
}
// stitch "locator" if it's a locator
OCompoundProperty oCompoundProp = outObj.getProperties();
if (isLocator)
{
const PropertyHeader * propHeaderPtr =
iCompoundProps[0].getPropertyHeader("locator");
stitchScalarProp(*propHeaderPtr,
iCompoundProps,
oCompoundProp);
}
}
else if (ISubD::matches(header))
{
OSubDSchema oSchema;
init< ISubD,
ISubDSchema,
OSubD,
OSubDSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the SubDSchema
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ISubDSchema iSchema =
ISubD(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IV2fGeomParam uvs = iSchema.getUVsParam();
if (i == 0 && uvs)
{
oSchema.setUVSourceName(GetSourceName(uvs.getMetaData()));
}
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
ISubDSchema::Sample iSamp = iSchema.getValue(reqIdx);
OSubDSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
Abc::Int32ArraySamplePtr faceIndicesPtr = iSamp.getFaceIndices();
if (faceIndicesPtr)
oSamp.setFaceIndices(*faceIndicesPtr);
Abc::Int32ArraySamplePtr faceCntPtr = iSamp.getFaceCounts();
if (faceCntPtr)
oSamp.setFaceCounts(*faceCntPtr);
oSamp.setFaceVaryingInterpolateBoundary(iSamp.getFaceVaryingInterpolateBoundary());
oSamp.setFaceVaryingPropagateCorners(iSamp.getFaceVaryingPropagateCorners());
oSamp.setInterpolateBoundary(iSamp.getInterpolateBoundary());
Abc::Int32ArraySamplePtr creaseIndicesPtr = iSamp.getCreaseIndices();
if (creaseIndicesPtr)
oSamp.setCreaseIndices(*creaseIndicesPtr);
Abc::Int32ArraySamplePtr creaseLenPtr = iSamp.getCreaseLengths();
if (creaseLenPtr)
oSamp.setCreaseLengths(*creaseLenPtr);
Abc::FloatArraySamplePtr creaseSpPtr = iSamp.getCreaseSharpnesses();
if (creaseSpPtr)
oSamp.setCreaseSharpnesses(*creaseSpPtr);
Abc::Int32ArraySamplePtr cornerIndicesPtr = iSamp.getCornerIndices();
if (cornerIndicesPtr)
oSamp.setCornerIndices(*cornerIndicesPtr);
Abc::FloatArraySamplePtr cornerSpPtr = iSamp.getCornerSharpnesses();
if (cornerSpPtr)
oSamp.setCreaseSharpnesses(*cornerSpPtr);
Abc::Int32ArraySamplePtr holePtr = iSamp.getHoles();
if (holePtr)
oSamp.setHoles(*holePtr);
oSamp.setSubdivisionScheme(iSamp.getSubdivisionScheme());
// set uvs
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
oSchema.set(oSamp);
}
}
}
else if (IPolyMesh::matches(header))
{
OPolyMeshSchema oSchema;
init< IPolyMesh,
IPolyMeshSchema,
OPolyMesh,
OPolyMeshSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the PolySchema
//
for (size_t i = 0; i < iObjects.size(); i++)
{
IPolyMeshSchema iSchema =
IPolyMesh(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IN3fGeomParam normals = iSchema.getNormalsParam();
IV2fGeomParam uvs = iSchema.getUVsParam();
if (i == 0 && uvs)
{
oSchema.setUVSourceName(GetSourceName(uvs.getMetaData()));
}
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
IPolyMeshSchema::Sample iSamp = iSchema.getValue(reqIdx);
OPolyMeshSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
Abc::Int32ArraySamplePtr faceIndicesPtr = iSamp.getFaceIndices();
if (faceIndicesPtr)
oSamp.setFaceIndices(*faceIndicesPtr);
Abc::Int32ArraySamplePtr faceCntPtr = iSamp.getFaceCounts();
if (faceCntPtr)
oSamp.setFaceCounts(*faceCntPtr);
// set uvs
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
// set normals
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (normals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(normals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
oSchema.set(oSamp);
}
}
}
else if (ICamera::matches(header))
{
OCameraSchema oSchema;
init< ICamera,
ICameraSchema,
OCamera,
OCameraSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the CameraSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ICameraSchema iSchema =
ICamera(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
oSchema.set(iSchema.getValue(reqIdx));
}
}
}
else if (ICurves::matches(header))
{
OCurvesSchema oSchema;
init< ICurves,
ICurvesSchema,
OCurves,
OCurvesSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the CurvesSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ICurvesSchema iSchema =
ICurves(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
IV2fGeomParam iUVs = iSchema.getUVsParam();
IN3fGeomParam iNormals = iSchema.getNormalsParam();
IFloatGeomParam iWidths = iSchema.getWidthsParam();
IFloatArrayProperty iKnots = iSchema.getKnotsProperty();
IUcharArrayProperty iOrders = iSchema.getOrdersProperty();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
ICurvesSchema::Sample iSamp = iSchema.getValue(reqIdx);
OCurvesSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
oSamp.setType(iSamp.getType());
Abc::Int32ArraySamplePtr curvsNumPtr = iSamp.getCurvesNumVertices();
if (curvsNumPtr)
oSamp.setCurvesNumVertices(*curvsNumPtr);
oSamp.setWrap(iSamp.getWrap());
oSamp.setBasis(iSamp.getBasis());
Abc::FloatArraySamplePtr knotsPtr = iSamp.getKnots();
if (knotsPtr)
{
oSamp.setKnots(*knotsPtr);
}
Abc::UcharArraySamplePtr ordersPtr = iSamp.getOrders();
if (ordersPtr)
{
oSamp.setOrders(*ordersPtr);
}
IFloatGeomParam::Sample iWidthSample;
OFloatGeomParam::Sample oWidthSample;
if (iWidths)
{
getOGeomParamSamp <IFloatGeomParam, IFloatGeomParam::Sample,
OFloatGeomParam::Sample>(iWidths, iWidthSample,
oWidthSample, reqIdx);
oSamp.setWidths(oWidthSample);
}
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (iUVs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(iUVs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (iNormals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(iNormals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
oSchema.set(oSamp);
}
}
}
else if (IPoints::matches(header))
{
OPointsSchema oSchema;
init< IPoints,
IPointsSchema,
OPoints,
OPointsSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the PointsSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
IPointsSchema iSchema =
IPoints(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
IFloatGeomParam iWidths = iSchema.getWidthsParam();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
IPointsSchema::Sample iSamp = iSchema.getValue(reqIdx);
OPointsSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::UInt64ArraySamplePtr idPtr = iSamp.getIds();
if (idPtr)
oSamp.setIds(*idPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
IFloatGeomParam::Sample iWidthSample;
OFloatGeomParam::Sample oWidthSample;
if (iWidths)
{
getOGeomParamSamp <IFloatGeomParam, IFloatGeomParam::Sample,
OFloatGeomParam::Sample>(iWidths, iWidthSample,
oWidthSample, reqIdx);
oSamp.setWidths(oWidthSample);
}
oSchema.set(oSamp);
}
}
}
else if (INuPatch::matches(header))
{
ONuPatchSchema oSchema;
init< INuPatch,
INuPatchSchema,
ONuPatch,
ONuPatchSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the NuPatchSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
INuPatchSchema iSchema =
INuPatch(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IN3fGeomParam normals = iSchema.getNormalsParam();
IV2fGeomParam uvs = iSchema.getUVsParam();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
INuPatchSchema::Sample iSamp = iSchema.getValue(reqIdx);
ONuPatchSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
oSamp.setNu(iSamp.getNumU());
oSamp.setNv(iSamp.getNumV());
oSamp.setUOrder(iSamp.getUOrder());
oSamp.setVOrder(iSamp.getVOrder());
Abc::FloatArraySamplePtr uKnotsPtr = iSamp.getUKnot();
if (uKnotsPtr)
oSamp.setUKnot(*uKnotsPtr);
Abc::FloatArraySamplePtr vKnotsPtr = iSamp.getVKnot();
if (vKnotsPtr)
oSamp.setVKnot(*vKnotsPtr);
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (normals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(normals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
if (iSchema.hasTrimCurve())
{
oSamp.setTrimCurve(iSamp.getTrimNumLoops(),
*(iSamp.getTrimNumCurves()),
*(iSamp.getTrimNumVertices()),
*(iSamp.getTrimOrders()),
*(iSamp.getTrimKnots()),
*(iSamp.getTrimMins()),
*(iSamp.getTrimMaxes()),
*(iSamp.getTrimU()),
*(iSamp.getTrimV()),
*(iSamp.getTrimW()));
}
oSchema.set(oSamp);
}
}
}
else
{
outObj = OObject(oParentObj, header.getName(), header.getMetaData());
// collect the top level compound property
ICompoundPropertyVec iCompoundProps(iObjects.size());
for (size_t i = 0; i < iObjects.size(); i++)
{
iCompoundProps[i] = iObjects[i].getProperties();
}
OCompoundProperty oCompoundProperty = outObj.getProperties();
stitchCompoundProp(iCompoundProps, oCompoundProperty);
}
// After done writing THIS OObject node, if input nodes have children,
// go deeper.
// Otherwise we are done here
size_t numChildren = iObjects[0].getNumChildren();
// check to make sure all of our iObjects have the same number of children
for (size_t j = 1; j < iObjects.size(); j++)
{
if (numChildren != iObjects[j].getNumChildren())
{
std::cerr << "ERROR: " << iObjects[j].getFullName() << " in " <<
iObjects[j].getArchive().getName() <<
" has a different number of children than " <<
iObjects[0].getFullName() << " in " <<
iObjects[0].getArchive().getName() << std::endl;
exit(1);
}
}
for (size_t i = 0 ; i < numChildren; i++ )
{
std::vector< IObject > iChildObjects;
for (size_t f = 0; f < iObjects.size(); f++)
{
iChildObjects.push_back(iObjects[f].getChild(i));
}
visitObjects(iChildObjects, outObj);
}
}