bool MayaMeshWriter::isMeshValid()
{
MStatus status = MS::kSuccess;
// Sanity checks
MFnMesh lMesh( getDagPath(), &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
return false;
}
unsigned int numVertices = lMesh.numVertices();
unsigned int numPolygons = lMesh.numPolygons();
if (numVertices < 3 && numVertices > 0)
{
MString err = lMesh.fullPathName() +
" is not a valid mesh, because it only has ";
err += numVertices;
err += " points.";
MGlobal::displayError(err);
}
if (numPolygons == 0)
{
MGlobal::displayWarning(lMesh.fullPathName() + " has no polygons.");
}
return true;
}
void MayaMeshWriter::writeColor()
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError(
"MFnMesh() failed for MayaMeshWriter::writeColor" );
return;
}
//Write colors
std::vector<Alembic::AbcGeom::OC4fGeomParam>::iterator rgbaIt;
std::vector<Alembic::AbcGeom::OC4fGeomParam>::iterator rgbaItEnd;
rgbaIt = mRGBAParams.begin();
rgbaItEnd = mRGBAParams.end();
for (; rgbaIt != rgbaItEnd; ++rgbaIt)
{
std::vector<float> colors;
std::vector< Alembic::Util::uint32_t > colorIndices;
MString colorSetName(rgbaIt->getName().c_str());
getColorSet(lMesh, &colorSetName, true, colors, colorIndices);
//cast the vector to the sample type
Alembic::AbcGeom::OC4fGeomParam::Sample samp(
Alembic::Abc::C4fArraySample(
(const Imath::C4f *) &colors.front(), colors.size()/4),
Alembic::Abc::UInt32ArraySample(colorIndices),
Alembic::AbcGeom::kFacevaryingScope );
rgbaIt->set(samp);
}
std::vector<Alembic::AbcGeom::OC3fGeomParam>::iterator rgbIt;
std::vector<Alembic::AbcGeom::OC3fGeomParam>::iterator rgbItEnd;
rgbIt = mRGBParams.begin();
rgbItEnd = mRGBParams.end();
for (; rgbIt != rgbItEnd; ++rgbIt)
{
std::vector<float> colors;
std::vector< Alembic::Util::uint32_t > colorIndices;
MString colorSetName(rgbIt->getName().c_str());
getColorSet(lMesh, &colorSetName, false, colors, colorIndices);
//cast the vector to the sample type
Alembic::AbcGeom::OC3fGeomParam::Sample samp(
Alembic::Abc::C3fArraySample(
(const Imath::C3f *) &colors.front(), colors.size()/3),
Alembic::Abc::UInt32ArraySample(colorIndices),
Alembic::AbcGeom::kFacevaryingScope);
rgbIt->set(samp);
}
}
void MayaMeshWriter::write()
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
Alembic::AbcGeom::OV2fGeomParam::Sample uvSamp;
std::vector<float> uvs;
std::vector<Alembic::Util::uint32_t> indices;
std::string uvSetName;
if (mWriteUVs || mWriteUVSets)
{
getUVs(uvs, indices, uvSetName);
if (!uvs.empty())
{
if (!uvSetName.empty())
{
if (mPolySchema.valid())
{
mPolySchema.setUVSourceName(uvSetName);
}
else if (mSubDSchema.valid())
{
mSubDSchema.setUVSourceName(uvSetName);
}
}
uvSamp.setScope( Alembic::AbcGeom::kFacevaryingScope );
uvSamp.setVals(Alembic::AbcGeom::V2fArraySample(
(const Imath::V2f *) &uvs.front(), uvs.size() / 2));
if (!indices.empty())
{
uvSamp.setIndices(Alembic::Abc::UInt32ArraySample(
&indices.front(), indices.size()));
}
}
}
std::vector<float> points;
std::vector<Alembic::Util::int32_t> facePoints;
std::vector<Alembic::Util::int32_t> faceList;
if (mPolySchema.valid())
{
writePoly(uvSamp);
}
else if (mSubDSchema.valid())
{
writeSubD(uvSamp);
}
}
unsigned int MayaMeshWriter::getNumFaces()
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
return lMesh.numPolygons();
}
void MayaMeshWriter::getUVs(std::vector<float> & uvs,
std::vector<Alembic::Util::uint32_t> & indices,
std::string & name)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
MString uvSetName = lMesh.currentUVSetName(&status);
if (uvSetName.length() != 0)
{
MFloatArray uArray, vArray;
status = lMesh.getUVs(uArray, vArray, &uvSetName);
// convert the raw uv list into vector uvsvec.clear();
if ( uArray.length() != vArray.length() )
{
MString msg = "uv Set" + uvSetName +
"uArray and vArray not the same length";
MGlobal::displayError(msg);
return;
}
if (uvSetName != "map1")
{
name = uvSetName.asChar();
}
unsigned int len = uArray.length();
uvs.clear();
uvs.reserve(len * 2);
for (unsigned int i = 0; i < len; i++)
{
uvs.push_back(uArray[i]);
uvs.push_back(vArray[i]);
}
indices.clear();
indices.reserve(lMesh.numFaceVertices());
int faceCount = lMesh.numPolygons();
int uvId = 0;
for (int f = 0; f < faceCount; f++)
{
int len = lMesh.polygonVertexCount(f);
for (int i = len-1; i >= 0; i--)
{
lMesh.getPolygonUVid(f, i, uvId, &uvSetName);
indices.push_back(uvId);
}
}
}
}
void MayaMeshWriter::writePoly(
const Alembic::AbcGeom::OV2fGeomParam::Sample & iUVs)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
std::vector<float> points;
std::vector<Alembic::Util::int32_t> facePoints;
std::vector<Alembic::Util::int32_t> pointCounts;
fillTopology(points, facePoints, pointCounts);
Alembic::AbcGeom::ON3fGeomParam::Sample normalsSamp;
std::vector<float> normals;
getPolyNormals(normals);
if (!normals.empty())
{
normalsSamp.setScope( Alembic::AbcGeom::kFacevaryingScope );
normalsSamp.setVals(Alembic::AbcGeom::N3fArraySample(
(const Imath::V3f *) &normals.front(), normals.size() / 3));
}
Alembic::AbcGeom::OPolyMeshSchema::Sample samp(
Alembic::Abc::V3fArraySample((const Imath::V3f *)&points.front(),
points.size() / 3),
Alembic::Abc::Int32ArraySample(facePoints),
Alembic::Abc::Int32ArraySample(pointCounts), iUVs, normalsSamp);
// if this mesh is animated, write out the animated geometry
if (mIsGeometryAnimated)
{
mPolySchema.set(samp);
}
else
{
mPolySchema.set(samp);
}
writeColor();
}
// virtual
bool MayaMeshWriter::writeMeshAttrs(const UsdTimeCode &usdTime, UsdGeomMesh &primSchema)
{
MStatus status = MS::kSuccess;
// Write parent class attrs
writeTransformAttrs(usdTime, primSchema);
// Return if usdTime does not match if shape is animated
if (usdTime.IsDefault() == isShapeAnimated() ) {
// skip shape as the usdTime does not match if shape isAnimated value
return true;
}
MFnMesh lMesh( getDagPath(), &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
return false;
}
unsigned int numVertices = lMesh.numVertices();
unsigned int numPolygons = lMesh.numPolygons();
// Set mesh attrs ==========
// Get points
// TODO: Use memcpy()
const float* mayaRawPoints = lMesh.getRawPoints(&status);
VtArray<GfVec3f> points(numVertices);
for (unsigned int i = 0; i < numVertices; i++) {
unsigned int floatIndex = i*3;
points[i].Set(mayaRawPoints[floatIndex],
mayaRawPoints[floatIndex+1],
mayaRawPoints[floatIndex+2]);
}
primSchema.GetPointsAttr().Set(points, usdTime); // ANIMATED
// Compute the extent using the raw points
VtArray<GfVec3f> extent(2);
UsdGeomPointBased::ComputeExtent(points, &extent);
primSchema.CreateExtentAttr().Set(extent, usdTime);
// Get faceVertexIndices
unsigned int numFaceVertices = lMesh.numFaceVertices(&status);
VtArray<int> faceVertexCounts(numPolygons);
VtArray<int> faceVertexIndices(numFaceVertices);
MIntArray mayaFaceVertexIndices; // used in loop below
unsigned int curFaceVertexIndex = 0;
for (unsigned int i = 0; i < numPolygons; i++) {
lMesh.getPolygonVertices(i, mayaFaceVertexIndices);
faceVertexCounts[i] = mayaFaceVertexIndices.length();
for (unsigned int j=0; j < mayaFaceVertexIndices.length(); j++) {
faceVertexIndices[ curFaceVertexIndex ] = mayaFaceVertexIndices[j]; // push_back
curFaceVertexIndex++;
}
}
primSchema.GetFaceVertexCountsAttr().Set(faceVertexCounts); // not animatable
primSchema.GetFaceVertexIndicesAttr().Set(faceVertexIndices); // not animatable
// Read usdSdScheme attribute. If not set, we default to defaultMeshScheme
// flag that can be user defined and initialized to catmullClark
TfToken sdScheme = PxrUsdMayaMeshUtil::getSubdivScheme(lMesh, getArgs().defaultMeshScheme);
primSchema.CreateSubdivisionSchemeAttr(VtValue(sdScheme), true);
// Polygonal Mesh Case
if (sdScheme==UsdGeomTokens->none) {
// Support for standard USD bool and with Mojito bool tag
TfToken normalInterp=PxrUsdMayaMeshUtil::getEmitNormals(lMesh, UsdGeomTokens->none);
if (normalInterp==UsdGeomTokens->faceVarying) {
// Get References to members of meshData object
MFloatVectorArray normalArray;
MFloatVectorArray vertexNormalArray;
lMesh.getNormals(normalArray, MSpace::kObject);
// Iterate through each face in the mesh.
vertexNormalArray.setLength(lMesh.numFaceVertices());
VtArray<GfVec3f> meshNormals(lMesh.numFaceVertices());
size_t faceVertIdx = 0;
for (MItMeshPolygon faceIter(getDagPath()); !faceIter.isDone(); faceIter.next()) {
// Iterate through each face-vertex.
for (size_t locVertIdx = 0; locVertIdx < faceIter.polygonVertexCount();
++locVertIdx, ++faceVertIdx) {
int index=faceIter.normalIndex(locVertIdx);
for (int j=0;j<3;j++) {
meshNormals[faceVertIdx][j]=normalArray[index][j];
}
}
}
primSchema.GetNormalsAttr().Set(meshNormals, usdTime);
primSchema.SetNormalsInterpolation(normalInterp);
}
} else {
TfToken sdInterpBound = PxrUsdMayaMeshUtil::getSubdivInterpBoundary(
lMesh, UsdGeomTokens->edgeAndCorner);
primSchema.CreateInterpolateBoundaryAttr(VtValue(sdInterpBound), true);
TfToken sdFVInterpBound = PxrUsdMayaMeshUtil::getSubdivFVInterpBoundary(
lMesh);
primSchema.CreateFaceVaryingLinearInterpolationAttr(
VtValue(sdFVInterpBound), true);
assignSubDivTagsToUSDPrim( lMesh, primSchema);
}
// Holes - we treat InvisibleFaces as holes
MUintArray mayaHoles = lMesh.getInvisibleFaces();
if (mayaHoles.length() > 0) {
VtArray<int> subdHoles(mayaHoles.length());
for (unsigned int i=0; i < mayaHoles.length(); i++) {
subdHoles[i] = mayaHoles[i];
}
// not animatable in Maya, so we'll set default only
primSchema.GetHoleIndicesAttr().Set(subdHoles);
}
// == Write UVSets as Vec2f Primvars
MStringArray uvSetNames;
if (getArgs().exportMeshUVs) {
status = lMesh.getUVSetNames(uvSetNames);
}
for (unsigned int i=0; i < uvSetNames.length(); i++) {
// Initialize the VtArray to the max possible size (facevarying)
VtArray<GfVec2f> uvValues(numFaceVertices);
TfToken interpolation=TfToken();
// Gather UV data and interpolation into a Vec2f VtArray and try to compress if possible
if (_GetMeshUVSetData(lMesh, uvSetNames[i], &uvValues, &interpolation) == MS::kSuccess) {
// XXX:bug 118447
// We should be able to configure the UV map name that triggers this
// behavior, and the name to which it exports.
// The UV Set "map1" is renamed st. This is a Pixar/USD convention
TfToken setName(uvSetNames[i].asChar());
if (setName == "map1") setName=UsdUtilsGetPrimaryUVSetName();
// Create the primvar and set the values
UsdGeomPrimvar uvSet =
primSchema.CreatePrimvar(setName, SdfValueTypeNames->Float2Array, interpolation);
uvSet.Set( uvValues ); // not animatable
}
}
// == Gather ColorSets
MStringArray colorSetNames;
if (getArgs().exportColorSets) {
status = lMesh.getColorSetNames(colorSetNames);
}
// shaderColor is used in our pipeline as displayColor.
// shaderColor is used to fill faces where the colorset is not assigned
MColorArray shaderColors;
MObjectArray shaderObjs;
VtArray<GfVec3f> shadersRGBData;
TfToken shadersRGBInterp;
VtArray<float> shadersAlphaData;
TfToken shadersAlphaInterp;
// If exportDisplayColor is set to true or we have color sets,
// gather color & opacity from the shader including per face
// assignment. Color set require this to initialize unauthored/unpainted faces
if (getArgs().exportDisplayColor or colorSetNames.length()>0) {
PxrUsdMayaUtil::GetLinearShaderColor(lMesh, numPolygons,
&shadersRGBData, &shadersRGBInterp,
&shadersAlphaData, &shadersAlphaInterp);
}
for (unsigned int i=0; i < colorSetNames.length(); i++) {
bool isDisplayColor=false;
if (colorSetNames[i]=="displayColor") {
if (not getArgs().exportDisplayColor)
continue;
isDisplayColor=true;
}
if (colorSetNames[i]=="displayOpacity") {
MGlobal::displayWarning("displayOpacity on mesh:" + lMesh.fullPathName() +
" is a reserved PrimVar name in USD. Skipping...");
continue;
}
VtArray<GfVec3f> RGBData;
TfToken RGBInterp;
VtArray<GfVec4f> RGBAData;
TfToken RGBAInterp;
VtArray<float> AlphaData;
TfToken AlphaInterp;
MFnMesh::MColorRepresentation colorSetRep;
bool clamped=false;
// If displayColor uses shaderValues for non authored areas
// and allow RGB and Alpha to have different interpolation
// For all other colorSets the non authored values are set
// to (1,1,1,1) and RGB and Alpha will have the same interplation
// since they will be emitted as a Vec4f
if (not _GetMeshColorSetData( lMesh, colorSetNames[i],
isDisplayColor,
shadersRGBData, shadersAlphaData,
&RGBData, &RGBInterp,
&RGBAData, &RGBAInterp,
&AlphaData, &AlphaInterp,
&colorSetRep, &clamped)) {
MGlobal::displayWarning("Unable to retrieve colorSet data: " +
colorSetNames[i] + " on mesh: "+ lMesh.fullPathName() + ". Skipping...");
continue;
}
if (isDisplayColor) {
// We tag the resulting displayColor/displayOpacity primvar as
// authored to make sure we reconstruct the colorset on import
// The RGB is also convererted From DisplayToLinear
_setDisplayPrimVar( primSchema, colorSetRep,
RGBData, RGBInterp,
AlphaData, AlphaInterp,
clamped, true);
} else {
TfToken colorSetNameToken = TfToken(
PxrUsdMayaUtil::SanitizeColorSetName(
std::string(colorSetNames[i].asChar())));
if (colorSetRep == MFnMesh::kAlpha) {
_createAlphaPrimVar(primSchema, colorSetNameToken,
AlphaData, AlphaInterp, clamped);
} else if (colorSetRep == MFnMesh::kRGB) {
_createRGBPrimVar(primSchema, colorSetNameToken,
RGBData, RGBInterp, clamped);
} else if (colorSetRep == MFnMesh::kRGBA) {
_createRGBAPrimVar(primSchema, colorSetNameToken,
RGBAData, RGBAInterp, clamped);
}
}
}
// Set displayColor and displayOpacity only if they are NOT authored already
// Since this primvar will come from the shader and not a colorset,
// we are not adding the clamp attribute as custom data
// If a displayColor/displayOpacity is added, it's not considered authored
// we don't need to reconstruct this as a colorset since it orgininated
// from bound shader[s], so the authored flag is set to false
// Given that this RGB is for display, we do DisplayToLinear conversion
if (getArgs().exportDisplayColor) {
_setDisplayPrimVar( primSchema, MFnMesh::kRGBA,
shadersRGBData, shadersRGBInterp,
shadersAlphaData, shadersAlphaInterp,
false, false);
}
return true;
}
void MayaMeshWriter::writeSubD(
const Alembic::AbcGeom::OV2fGeomParam::Sample & iUVs)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
std::vector<float> points;
std::vector<Alembic::Util::int32_t> facePoints;
std::vector<Alembic::Util::int32_t> pointCounts;
fillTopology(points, facePoints, pointCounts);
Alembic::AbcGeom::OSubDSchema::Sample samp(
Alembic::AbcGeom::V3fArraySample((const Imath::V3f *)&points.front(),
points.size() / 3),
Alembic::Abc::Int32ArraySample(facePoints),
Alembic::Abc::Int32ArraySample(pointCounts));
samp.setUVs( iUVs );
MPlug plug = lMesh.findPlug("faceVaryingInterpolateBoundary");
if (!plug.isNull())
samp.setFaceVaryingInterpolateBoundary(plug.asInt());
plug = lMesh.findPlug("interpolateBoundary");
if (!plug.isNull())
samp.setInterpolateBoundary(plug.asInt());
plug = lMesh.findPlug("faceVaryingPropagateCorners");
if (!plug.isNull())
samp.setFaceVaryingPropagateCorners(plug.asInt());
std::vector <Alembic::Util::int32_t> creaseIndices;
std::vector <Alembic::Util::int32_t> creaseLengths;
std::vector <float> creaseSharpness;
std::vector <Alembic::Util::int32_t> cornerIndices;
std::vector <float> cornerSharpness;
MUintArray edgeIds;
MDoubleArray creaseData;
if (lMesh.getCreaseEdges(edgeIds, creaseData) == MS::kSuccess)
{
unsigned int numCreases = creaseData.length();
creaseIndices.resize(numCreases * 2);
creaseLengths.resize(numCreases, 2);
creaseSharpness.resize(numCreases);
for (unsigned int i = 0; i < numCreases; ++i)
{
int verts[2];
lMesh.getEdgeVertices(edgeIds[i], verts);
creaseIndices[2 * i] = verts[0];
creaseIndices[2 * i + 1] = verts[1];
creaseSharpness[i] = static_cast<float>(creaseData[i]);
}
samp.setCreaseIndices(Alembic::Abc::Int32ArraySample(creaseIndices));
samp.setCreaseLengths(Alembic::Abc::Int32ArraySample(creaseLengths));
samp.setCreaseSharpnesses(
Alembic::Abc::FloatArraySample(creaseSharpness));
}
MUintArray cornerIds;
MDoubleArray cornerData;
if (lMesh.getCreaseVertices(cornerIds, cornerData) == MS::kSuccess)
{
unsigned int numCorners = cornerIds.length();
cornerIndices.resize(numCorners);
cornerSharpness.resize(numCorners);
for (unsigned int i = 0; i < numCorners; ++i)
{
cornerIndices[i] = cornerIds[i];
cornerSharpness[i] = static_cast<float>(cornerData[i]);
}
samp.setCornerSharpnesses(
Alembic::Abc::FloatArraySample(cornerSharpness));
samp.setCornerIndices(
Alembic::Abc::Int32ArraySample(cornerIndices));
}
#if MAYA_API_VERSION >= 201100
MUintArray holes = lMesh.getInvisibleFaces();
unsigned int numHoles = holes.length();
std::vector <Alembic::Util::int32_t> holeIndices(numHoles);
for (unsigned int i = 0; i < numHoles; ++i)
{
holeIndices[i] = holes[i];
}
if (!holeIndices.empty())
{
samp.setHoles(holeIndices);
}
#endif
mSubDSchema.set(samp);
writeColor();
writeUVSets();
}
void MayaMeshWriter::getPolyNormals(std::vector<float> & oNormals)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
// no normals bail early
if (mNoNormals)
{
return;
}
MPlug plug = lMesh.findPlug("noNormals", true, &status);
if (status == MS::kSuccess && plug.asBool() == true)
{
return;
}
// we need to check the locked state of the normals
else if ( status != MS::kSuccess )
{
bool userSetNormals = false;
// go through all per face-vertex normals and verify if any of them
// has been tweaked by users
unsigned int numFaces = lMesh.numPolygons();
for (unsigned int faceIndex = 0; faceIndex < numFaces; faceIndex++)
{
MIntArray normals;
lMesh.getFaceNormalIds(faceIndex, normals);
unsigned int numNormals = normals.length();
for (unsigned int n = 0; n < numNormals; n++)
{
if (lMesh.isNormalLocked(normals[n]))
{
userSetNormals = true;
break;
}
}
}
// we looped over all the normals and they were all calculated by Maya
// so we just need to check to see if any of the edges are hard
// before we decide not to write the normals.
if (!userSetNormals)
{
bool hasHardEdges = false;
// go through all edges and verify if any of them is hard edge
unsigned int numEdges = lMesh.numEdges();
for (unsigned int edgeIndex = 0; edgeIndex < numEdges; edgeIndex++)
{
if (!lMesh.isEdgeSmooth(edgeIndex))
{
hasHardEdges = true;
break;
}
}
// all the edges were smooth, we don't need to write the normals
if (!hasHardEdges)
{
return;
}
}
}
bool flipNormals = false;
plug = lMesh.findPlug("flipNormals", true, &status);
if ( status == MS::kSuccess )
flipNormals = plug.asBool();
// get the per vertex per face normals (aka vertex)
unsigned int numFaces = lMesh.numPolygons();
for (unsigned int faceIndex = 0; faceIndex < numFaces; faceIndex++ )
{
MIntArray vertexList;
lMesh.getPolygonVertices(faceIndex, vertexList);
// re-pack the order of normals in this vector before writing into prop
// so that Renderman can also use it
unsigned int numVertices = vertexList.length();
for ( int v = numVertices-1; v >=0; v-- )
{
unsigned int vertexIndex = vertexList[v];
MVector normal;
lMesh.getFaceVertexNormal(faceIndex, vertexIndex, normal);
if (flipNormals)
normal = -normal;
oNormals.push_back(static_cast<float>(normal[0]));
oNormals.push_back(static_cast<float>(normal[1]));
oNormals.push_back(static_cast<float>(normal[2]));
}
}
}
MayaMeshWriter::MayaMeshWriter(MDagPath & iDag,
Alembic::Abc::OObject & iParent, Alembic::Util::uint32_t iTimeIndex,
const JobArgs & iArgs, GetMembersMap& gmMap)
: mNoNormals(iArgs.noNormals),
mWriteUVs(iArgs.writeUVs),
mWriteColorSets(iArgs.writeColorSets),
mWriteUVSets(iArgs.writeUVSets),
mIsGeometryAnimated(false),
mDagPath(iDag)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
// intermediate objects aren't translated
MObject surface = iDag.node();
if (iTimeIndex != 0 && util::isAnimated(surface))
{
mIsGeometryAnimated = true;
}
else
{
iTimeIndex = 0;
}
std::vector<float> uvs;
std::vector<Alembic::Util::uint32_t> indices;
std::string uvSetName;
MString name = lMesh.name();
name = util::stripNamespaces(name, iArgs.stripNamespace);
// check to see if this poly has been tagged as a SubD
MPlug plug = lMesh.findPlug("SubDivisionMesh");
if ( !plug.isNull() && plug.asBool() )
{
Alembic::AbcGeom::OSubD obj(iParent, name.asChar(), iTimeIndex);
mSubDSchema = obj.getSchema();
Alembic::AbcGeom::OV2fGeomParam::Sample uvSamp;
if (mWriteUVs || mWriteUVSets)
{
getUVs(uvs, indices, uvSetName);
if (!uvs.empty())
{
if (!uvSetName.empty())
{
mSubDSchema.setUVSourceName(uvSetName);
}
uvSamp.setScope( Alembic::AbcGeom::kFacevaryingScope );
uvSamp.setVals(Alembic::AbcGeom::V2fArraySample(
(const Imath::V2f *) &uvs.front(), uvs.size() / 2));
if (!indices.empty())
{
uvSamp.setIndices(Alembic::Abc::UInt32ArraySample(
&indices.front(), indices.size()));
}
}
}
Alembic::Abc::OCompoundProperty cp;
Alembic::Abc::OCompoundProperty up;
if (AttributesWriter::hasAnyAttr(lMesh, iArgs))
{
cp = mSubDSchema.getArbGeomParams();
up = mSubDSchema.getUserProperties();
}
mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, lMesh,
iTimeIndex, iArgs));
writeSubD(uvSamp);
}
else
{
Alembic::AbcGeom::OPolyMesh obj(iParent, name.asChar(), iTimeIndex);
mPolySchema = obj.getSchema();
Alembic::AbcGeom::OV2fGeomParam::Sample uvSamp;
if (mWriteUVs || mWriteUVSets)
{
getUVs(uvs, indices, uvSetName);
if (!uvs.empty())
{
if (!uvSetName.empty())
{
mPolySchema.setUVSourceName(uvSetName);
}
uvSamp.setScope( Alembic::AbcGeom::kFacevaryingScope );
uvSamp.setVals(Alembic::AbcGeom::V2fArraySample(
(const Imath::V2f *) &uvs.front(), uvs.size() / 2));
if (!indices.empty())
{
uvSamp.setIndices(Alembic::Abc::UInt32ArraySample(
&indices.front(), indices.size()));
}
}
}
Alembic::Abc::OCompoundProperty cp;
Alembic::Abc::OCompoundProperty up;
if (AttributesWriter::hasAnyAttr(lMesh, iArgs))
{
cp = mPolySchema.getArbGeomParams();
up = mPolySchema.getUserProperties();
}
// set the rest of the props and write to the writer node
mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, lMesh,
iTimeIndex, iArgs));
writePoly(uvSamp);
}
if (mWriteColorSets)
{
MStringArray colorSetNames;
lMesh.getColorSetNames(colorSetNames);
if (colorSetNames.length() > 0)
{
// Create the color sets compound prop
Alembic::Abc::OCompoundProperty arbParams;
if (mPolySchema.valid())
{
arbParams = mPolySchema.getArbGeomParams();
}
else
{
arbParams = mSubDSchema.getArbGeomParams();
}
std::string currentColorSet = lMesh.currentColorSetName().asChar();
for (unsigned int i=0; i < colorSetNames.length(); ++i)
{
// Create an array property for each color set
std::string colorSetPropName = colorSetNames[i].asChar();
Alembic::AbcCoreAbstract::MetaData md;
if (currentColorSet == colorSetPropName)
{
md.set("mayaColorSet", "1");
}
else
{
md.set("mayaColorSet", "0");
}
if (lMesh.getColorRepresentation(colorSetNames[i]) ==
MFnMesh::kRGB)
{
Alembic::AbcGeom::OC3fGeomParam colorProp(arbParams,
colorSetPropName, true,
Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex, md);
mRGBParams.push_back(colorProp);
}
else
{
Alembic::AbcGeom::OC4fGeomParam colorProp(arbParams,
colorSetPropName, true,
Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex, md);
mRGBAParams.push_back(colorProp);
}
}
writeColor();
}
}
if (mWriteUVSets)
{
MStringArray uvSetNames;
lMesh.getUVSetNames(uvSetNames);
unsigned int uvSetNamesLen = uvSetNames.length();
if (uvSetNamesLen > 1)
{
// Create the uv sets compound prop
Alembic::Abc::OCompoundProperty arbParams;
if (mPolySchema.valid())
{
arbParams = mPolySchema.getArbGeomParams();
}
else
{
arbParams = mSubDSchema.getArbGeomParams();
}
MString currentUV = lMesh.currentUVSetName();
for (unsigned int i = 0; i < uvSetNamesLen; ++i)
{
// Create an array property for each uv set
MString uvSetPropName = uvSetNames[i];
// the current UV set gets mapped to the primary UVs
if (currentUV == uvSetPropName)
{
continue;
}
if (uvSetPropName.length() > 0 &&
lMesh.numUVs(uvSetPropName) > 0)
{
mUVparams.push_back(Alembic::AbcGeom::OV2fGeomParam(
arbParams, uvSetPropName.asChar(), true,
Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex));
}
}
writeUVSets();
}
}
// write out facesets
if(!iArgs.writeFaceSets)
return;
// get the connected shading engines
MObjectArray connSGObjs (getOutConnectedSG(mDagPath));
const unsigned int sgCount = connSGObjs.length();
for (unsigned int i = 0; i < sgCount; ++i)
{
MObject connSGObj, compObj;
connSGObj = connSGObjs[i];
MFnDependencyNode fnDepNode(connSGObj);
MString connSgObjName = fnDepNode.name();
// retrive the component MObject
status = getSetComponents(mDagPath, connSGObj, gmMap, compObj);
if (status != MS::kSuccess)
{
// for some reason the shading group doesn't represent a face set
continue;
}
// retrieve the face indices
MIntArray indices;
MFnSingleIndexedComponent compFn;
compFn.setObject(compObj);
compFn.getElements(indices);
const unsigned int numData = indices.length();
// encountered the whole object mapping. skip it.
if (numData == 0)
continue;
std::vector<Alembic::Util::int32_t> faceIndices(numData);
for (unsigned int j = 0; j < numData; ++j)
{
faceIndices[j] = indices[j];
}
connSgObjName = util::stripNamespaces(connSgObjName,
iArgs.stripNamespace);
Alembic::AbcGeom::OFaceSet faceSet;
std::string faceSetName(connSgObjName.asChar());
MPlug abcFacesetNamePlug = fnDepNode.findPlug("AbcFacesetName", true);
if (!abcFacesetNamePlug.isNull())
{
faceSetName = abcFacesetNamePlug.asString().asChar();
}
if (mPolySchema.valid())
{
if (mPolySchema.hasFaceSet(faceSetName))
{
faceSet = mPolySchema.getFaceSet(faceSetName);
}
else
{
faceSet = mPolySchema.createFaceSet(faceSetName);
}
}
else
{
if (mSubDSchema.hasFaceSet(faceSetName))
{
faceSet = mSubDSchema.getFaceSet(faceSetName);
}
else
{
faceSet = mSubDSchema.createFaceSet(faceSetName);
}
}
Alembic::AbcGeom::OFaceSetSchema::Sample samp;
samp.setFaces(Alembic::Abc::Int32ArraySample(faceIndices));
Alembic::AbcGeom::OFaceSetSchema faceSetSchema = faceSet.getSchema();
faceSetSchema.set(samp);
faceSetSchema.setFaceExclusivity(Alembic::AbcGeom::kFaceSetExclusive);
MFnDependencyNode iNode(connSGObj);
Alembic::Abc::OCompoundProperty cp;
Alembic::Abc::OCompoundProperty up;
if (AttributesWriter::hasAnyAttr(iNode, iArgs))
{
cp = faceSetSchema.getArbGeomParams();
up = faceSetSchema.getUserProperties();
}
AttributesWriter attrWriter(cp, up, faceSet, iNode, iTimeIndex, iArgs);
attrWriter.write();
}
}
// the arrays being passed in are assumed to be empty
void MayaMeshWriter::fillTopology(
std::vector<float> & oPoints,
std::vector<Alembic::Util::int32_t> & oFacePoints,
std::vector<Alembic::Util::int32_t> & oPointCounts)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
MFloatPointArray pts;
lMesh.getPoints(pts);
if (pts.length() < 3 && pts.length() > 0)
{
MString err = lMesh.fullPathName() +
" is not a valid mesh, because it only has ";
err += pts.length();
err += " points.";
MGlobal::displayError(err);
return;
}
unsigned int numPolys = lMesh.numPolygons();
if (numPolys == 0)
{
MGlobal::displayWarning(lMesh.fullPathName() + " has no polygons.");
return;
}
unsigned int i;
int j;
oPoints.resize(pts.length() * 3);
// repack the float
for (i = 0; i < pts.length(); i++)
{
size_t local = i * 3;
oPoints[local] = pts[i].x;
oPoints[local+1] = pts[i].y;
oPoints[local+2] = pts[i].z;
}
/*
oPoints -
oFacePoints - vertex list
oPointCounts - number of points per polygon
*/
MIntArray faceArray;
for (i = 0; i < numPolys; i++)
{
lMesh.getPolygonVertices(i, faceArray);
if (faceArray.length() < 3)
{
MGlobal::displayWarning("Skipping degenerate polygon");
continue;
}
// write backwards cause polygons in Maya are in a different order
// from Renderman (clockwise vs counter-clockwise?)
int faceArrayLength = faceArray.length() - 1;
for (j = faceArrayLength; j > -1; j--)
{
oFacePoints.push_back(faceArray[j]);
}
oPointCounts.push_back(faceArray.length());
}
}