bool validateCurveData(Abc::P3fArraySamplePtr pCurvePos,
Abc::Int32ArraySamplePtr pCurveNbVertices,
Abc::UInt16ArraySamplePtr pOrders,
Abc::FloatArraySamplePtr pKnotVec, AbcG::CurveType type)
{
ESS_PROFILE_FUNC();
int nDefaultOrder = 4;
const int numCurves = (int)pCurveNbVertices->size();
const int numControl = (int)pCurvePos->size();
int numControlNB = 0;
for (int i = 0; i < pCurveNbVertices->size(); i++) {
numControlNB += pCurveNbVertices->get()[i];
}
if (numControl != numControlNB) {
ESS_LOG_ERROR(
"Size mismatch between vertices and nbVertices. Cannot load curve.");
return false;
}
if (pOrders && pCurveNbVertices->size() != pOrders->size()) {
ESS_LOG_ERROR(
"Size mismatch between numOrders and nbVertices. Cannot load curve.");
return false;
}
if (pKnotVec) {
int abcTotalKnots = 0; // numControl + numCurves * (nDefaultOrder - 2) ;
if (pOrders) {
// calculate the expected knot vec size
for (int i = 0; i < pCurveNbVertices->size(); i++) {
abcTotalKnots += pCurveNbVertices->get()[i] + pOrders->get()[i] - 2;
}
}
else { // single order
int nOrder = 0;
if (type == AbcG::kCubic) {
nOrder = 4;
}
else if (type == AbcG::kLinear) {
nOrder = 2;
}
abcTotalKnots = numControl + numCurves * (nOrder - 2);
}
if (abcTotalKnots != pKnotVec->size()) {
ESS_LOG_ERROR("Knot vector has the wrong size. Cannot load curve.");
}
}
return true;
}
int getCurveOrder(int i, Abc::UInt16ArraySamplePtr pOrders, AbcG::CurveType type)
{
if(pOrders){
return pOrders->get()[i];
}
else if(type == AbcG::kCubic){
return 4;
}
else if(type == AbcG::kLinear){
return 2;
}
return 4;
}
MStatus AlembicCurvesNode::compute(const MPlug &plug, MDataBlock &dataBlock)
{
ESS_PROFILE_SCOPE("AlembicCurvesNode::compute");
MStatus status;
// update the frame number to be imported
const double inputTime =
dataBlock.inputValue(mTimeAttr).asTime().as(MTime::kSeconds);
MString &fileName = dataBlock.inputValue(mFileNameAttr).asString();
MString &identifier = dataBlock.inputValue(mIdentifierAttr).asString();
// check if we have the file
if (fileName != mFileName || identifier != mIdentifier) {
mSchema.reset();
if (fileName != mFileName) {
delRefArchive(mFileName);
mFileName = fileName;
addRefArchive(mFileName);
}
mIdentifier = identifier;
// get the object from the archive
Abc::IObject iObj = getObjectFromArchive(mFileName, identifier);
if (!iObj.valid()) {
MGlobal::displayWarning("[ExocortexAlembic] Identifier '" + identifier +
"' not found in archive '" + mFileName + "'.");
return MStatus::kFailure;
}
AbcG::ICurves obj(iObj, Abc::kWrapExisting);
if (!obj.valid()) {
MGlobal::displayWarning("[ExocortexAlembic] Identifier '" + identifier +
"' in archive '" + mFileName +
"' is not a Curves.");
return MStatus::kFailure;
}
mObj = obj;
mSchema = obj.getSchema();
mCurvesData = MObject::kNullObj;
}
if (!mSchema.valid()) {
return MStatus::kFailure;
}
{
ESS_PROFILE_SCOPE("AlembicCurvesNode::compute readProps");
Alembic::Abc::ICompoundProperty arbProp = mSchema.getArbGeomParams();
Alembic::Abc::ICompoundProperty userProp = mSchema.getUserProperties();
readProps(inputTime, arbProp, dataBlock, thisMObject());
readProps(inputTime, userProp, dataBlock, thisMObject());
// Set all plugs as clean
// Even if one of them failed to get set,
// trying again in this frame isn't going to help
for (unsigned int i = 0; i < mGeomParamPlugs.length(); i++) {
dataBlock.outputValue(mGeomParamPlugs[i]).setClean();
}
for (unsigned int i = 0; i < mUserAttrPlugs.length(); i++) {
dataBlock.outputValue(mUserAttrPlugs[i]).setClean();
}
}
// get the sample
SampleInfo sampleInfo = getSampleInfo(inputTime, mSchema.getTimeSampling(),
mSchema.getNumSamples());
// check if we have to do this at all
if (!mCurvesData.isNull() &&
mLastSampleInfo.floorIndex == sampleInfo.floorIndex &&
mLastSampleInfo.ceilIndex == sampleInfo.ceilIndex) {
return MStatus::kSuccess;
}
mLastSampleInfo = sampleInfo;
const float blend = (float)sampleInfo.alpha;
// access the camera values
AbcG::ICurvesSchema::Sample sample;
AbcG::ICurvesSchema::Sample sample2;
mSchema.get(sample, sampleInfo.floorIndex);
if (blend != 0.0f) {
mSchema.get(sample2, sampleInfo.ceilIndex);
}
Abc::P3fArraySamplePtr samplePos = sample.getPositions();
Abc::P3fArraySamplePtr samplePos2 = sample2.getPositions();
Abc::Int32ArraySamplePtr nbVertices = sample.getCurvesNumVertices();
const bool applyBlending =
(blend == 0.0f) ? false : (samplePos->size() == samplePos2->size());
Abc::FloatArraySamplePtr pKnotVec = getKnotVector(mObj);
Abc::UInt16ArraySamplePtr pOrders = getCurveOrders(mObj);
MArrayDataHandle arrh = dataBlock.outputArrayValue(mOutGeometryAttr);
MArrayDataBuilder builder = arrh.builder();
// reference:
// http://download.autodesk.com/us/maya/2010help/API/multi_curve_node_8cpp-example.html
const int degree = (sample.getType() == AbcG::kCubic) ? 3 : 1;
const bool closed = (sample.getWrap() == AbcG::kPeriodic);
unsigned int pointOffset = 0;
unsigned int knotOffset = 0;
for (int ii = 0; ii < nbVertices->size(); ++ii) {
const unsigned int nbCVs = (unsigned int)nbVertices->get()[ii];
const int ldegree = (pOrders) ? pOrders->get()[ii] : degree;
const int nbSpans = (int)nbCVs - ldegree;
MDoubleArray knots;
if (pKnotVec) {
const unsigned int nb_knot = nbCVs + ldegree - 1;
for (unsigned int i = 0; i < nb_knot; ++i) {
knots.append(pKnotVec->get()[knotOffset + i]);
}
knotOffset += nb_knot;
}
else {
for (int span = 0; span <= nbSpans; ++span) {
knots.append(double(span));
if (span == 0 || span == nbSpans) {
for (int m = 1; m < degree; ++m) {
knots.append(double(span));
}
}
}
}
MPointArray points;
if (samplePos->size() > 0) {
points.setLength((unsigned int)nbCVs);
if (applyBlending) {
for (unsigned int i = 0; i < nbCVs; ++i) {
const Abc::P3fArraySample::value_type &vals1 =
samplePos->get()[pointOffset + i];
const Abc::P3fArraySample::value_type &vals2 =
samplePos2->get()[pointOffset + i];
MPoint &pt = points[i];
pt.x = vals1.x + (vals2.x - vals1.x) * blend;
pt.y = vals1.y + (vals2.y - vals1.y) * blend;
pt.z = vals1.z + (vals2.z - vals1.z) * blend;
}
}
else {
for (unsigned int i = 0; i < nbCVs; ++i) {
const Abc::P3fArraySample::value_type &vals =
samplePos->get()[pointOffset + i];
MPoint &pt = points[i];
pt.x = vals.x;
pt.y = vals.y;
pt.z = vals.z;
}
}
pointOffset += nbCVs;
}
// create a subd either with or without uvs
MObject mmCurvesData = MFnNurbsCurveData().create();
if (ldegree == 1 || ldegree == 3)
mCurves.create(points, knots, ldegree,
closed ? MFnNurbsCurve::kClosed : MFnNurbsCurve::kOpen,
false, false, mmCurvesData);
builder.addElement(ii).set(mmCurvesData);
}
arrh.set(builder);
arrh.setAllClean();
return MStatus::kSuccess;
}