MObject createSubD(double iFrame, SubDAndColors & iNode,
MObject & iParent)
{
Alembic::AbcGeom::ISubDSchema schema = iNode.mMesh.getSchema();
Alembic::AbcCoreAbstract::index_t index, ceilIndex;
getWeightAndIndex(iFrame, schema.getTimeSampling(),
schema.getNumSamples(), index, ceilIndex);
Alembic::AbcGeom::ISubDSchema::Sample samp;
schema.get(samp, Alembic::Abc::ISampleSelector(index));
MString name(iNode.mMesh.getName().c_str());
MFnMesh fnMesh;
MFloatPointArray pointArray;
Alembic::Abc::P3fArraySamplePtr emptyPtr;
fillPoints(pointArray, samp.getPositions(), emptyPtr, 0.0);
fillTopology(fnMesh, iParent, pointArray, samp.getFaceIndices(),
samp.getFaceCounts());
fnMesh.setName(iNode.mMesh.getName().c_str());
setInitialShadingGroup(fnMesh.partialPathName());
MObject obj = fnMesh.object();
setUVs(iFrame, fnMesh, schema.getUVsParam());
setColors(iFrame, fnMesh, iNode.mC3s, iNode.mC4s, true);
// add the mFn-specific attributes to fnMesh node
MFnNumericAttribute numAttr;
MString attrName("SubDivisionMesh");
MObject attrObj = numAttr.create(attrName, attrName,
MFnNumericData::kBoolean, 1);
numAttr.setKeyable(true);
numAttr.setHidden(false);
fnMesh.addAttribute(attrObj, MFnDependencyNode::kLocalDynamicAttr);
if (samp.getInterpolateBoundary() > 0)
{
attrName = MString("interpolateBoundary");
attrObj = numAttr.create(attrName, attrName, MFnNumericData::kBoolean,
samp.getInterpolateBoundary());
numAttr.setKeyable(true);
numAttr.setHidden(false);
fnMesh.addAttribute(attrObj, MFnDependencyNode::kLocalDynamicAttr);
}
if (samp.getFaceVaryingInterpolateBoundary() > 0)
{
attrName = MString("faceVaryingInterpolateBoundary");
attrObj = numAttr.create(attrName, attrName, MFnNumericData::kBoolean,
samp.getFaceVaryingInterpolateBoundary());
numAttr.setKeyable(true);
numAttr.setHidden(false);
fnMesh.addAttribute(attrObj, MFnDependencyNode::kLocalDynamicAttr);
}
if (samp.getFaceVaryingPropagateCorners() > 0)
{
attrName = MString("faceVaryingPropagateCorners");
attrObj = numAttr.create(attrName, attrName, MFnNumericData::kBoolean,
samp.getFaceVaryingPropagateCorners());
numAttr.setKeyable(true);
numAttr.setHidden(false);
fnMesh.addAttribute(attrObj, MFnDependencyNode::kLocalDynamicAttr);
}
#if MAYA_API_VERSION >= 201100
Alembic::Abc::Int32ArraySamplePtr holes = samp.getHoles();
if (holes && !holes->size() == 0)
{
unsigned int numHoles = (unsigned int)holes->size();
MUintArray holeData(numHoles);
for (unsigned int i = 0; i < numHoles; ++i)
{
holeData[i] = (*holes)[i];
}
if (fnMesh.setInvisibleFaces(holeData) != MS::kSuccess)
{
MString warn = "Failed to set holes on: ";
warn += iNode.mMesh.getName().c_str();
printWarning(warn);
}
}
#endif
Alembic::Abc::FloatArraySamplePtr creases = samp.getCreaseSharpnesses();
if (creases && !creases->size() == 0)
{
Alembic::Abc::Int32ArraySamplePtr indices = samp.getCreaseIndices();
Alembic::Abc::Int32ArraySamplePtr lengths = samp.getCreaseLengths();
std::size_t numLengths = lengths->size();
MUintArray edgeIds;
MDoubleArray creaseData;
std::size_t curIndex = 0;
// curIndex incremented here to move on to the next crease length
for (std::size_t i = 0; i < numLengths; ++i, ++curIndex)
{
std::size_t len = (*lengths)[i] - 1;
float creaseSharpness = (*creases)[i];
// curIndex incremented here to go between all the edges that make
// up a given length
for (std::size_t j = 0; j < len; ++j, ++curIndex)
{
Alembic::Util::int32_t vertA = (*indices)[curIndex];
Alembic::Util::int32_t vertB = (*indices)[curIndex+1];
MItMeshVertex itv(obj);
int prev;
itv.setIndex(vertA, prev);
MIntArray edges;
itv.getConnectedEdges(edges);
std::size_t numEdges = edges.length();
for (unsigned int k = 0; k < numEdges; ++k)
{
int oppVert = -1;
itv.getOppositeVertex(oppVert, edges[k]);
if (oppVert == vertB)
{
creaseData.append(creaseSharpness);
edgeIds.append(edges[k]);
break;
}
}
}
}
if (fnMesh.setCreaseEdges(edgeIds, creaseData) != MS::kSuccess)
{
MString warn = "Failed to set creases on: ";
warn += iNode.mMesh.getName().c_str();
printWarning(warn);
}
}
Alembic::Abc::FloatArraySamplePtr corners = samp.getCornerSharpnesses();
if (corners && !corners->size() == 0)
{
Alembic::Abc::Int32ArraySamplePtr cornerVerts = samp.getCornerIndices();
unsigned int numCorners = static_cast<unsigned int>(corners->size());
MUintArray vertIds(numCorners);
MDoubleArray cornerData(numCorners);
for (unsigned int i = 0; i < numCorners; ++i)
{
cornerData[i] = (*corners)[i];
vertIds[i] = (*cornerVerts)[i];
}
if (fnMesh.setCreaseVertices(vertIds, cornerData) != MS::kSuccess)
{
MString warn = "Failed to set corners on: ";
warn += iNode.mMesh.getName().c_str();
printWarning(warn);
}
}
return obj;
}
//------------------------------------------------------------------------------
void LoadConfiguration::removeBonds()
{
#if 0
int nRemoveBonds = 0;
// Checks if there exists a file containing a hasmap of all the bonds.
if(pathOfHoles != "" && localDim == 2)
{
IVEC3 sizeOfImage;
std::ifstream holeData( pathOfHoles, ios::in);
string line;
getline(holeData, line);
std::vector<std::string> lineSplit = split(line, ' ');
sizeOfImage[0] = std::stoi(lineSplit[0]);
sizeOfImage[1] = std::stoi(lineSplit[1]);
sizeOfImage[2] = std::stoi(lineSplit[2]);
double X0 = domain.dom[0][1] - domain.dom[0][0];
double Y0 = domain.dom[1][1] - domain.dom[1][0];
// Finding the optimal length
int nx = floor( (X0)/spacing );
int ny = floor( (Y0)/spacing );
bool holes[nx][ny];
// Zeroing the holes
for(int i=0;i<nx;i++){
for(int j=0;j<ny;j++){
holes[i][j] = 0;
}
}
if(holeData.is_open() )
{
while(getline(holeData, line))
{
std::vector<std::string> lineSplit = split(line, ' ');
double x = std::stof(lineSplit[0]);
double y = std::stof(lineSplit[1]);
int id_x = (x - dom[0][0])/spacing;
int id_y = (y - dom[1][0])/spacing;
// if(id_x<0)
// id_x = 0;
// if(id_x>nx-1)
// id_x = nx-1;
// if(id_y<0)
// id_y = 0;
// if(id_y>ny-1)
// id_y = ny-1;
holes[id_x][id_y] = true;
}
holeData.close();
}
// Checking for holes
int nCheckPoints = int(delta/spacing);
//#ifdef _OPENMP
//# pragma omp parallel for schedule(runtime)
//#endif
for(int i=0;i<domain.myGrid.size(); i++)
{
VEC3 r;
VEC3 dr;
int gridId = domain.myGrid[i];
GridPoint * gridPoint = domain.grid[gridId];
for(Particle * p_i:gridPoint->getParticles())
{
const double *r_i = p_i->getR0_memptr();
unordered_map<int, PD_connectionData> & PDconnections = p_i->getPDConnectionsData();
for(pair<const int, PD_connectionData> &con:PDconnections)
{
Particle * p_j = domain.findParticle( con.first );
const double *r_j = p_j->getR0_memptr();
dr[0] = r_j[0] - r_i[0];
dr[1] = r_j[1] - r_i[1];
domain.minimumImageConvection(dr);
dr[0] /= nCheckPoints;
dr[1] /= nCheckPoints;
for(int i=1; i<nCheckPoints;i++)
{
r[0] = r_i[0] + dr[0]*i;
r[1] = r_i[1] + dr[1]*i;
// domain.minimumImageConvection(r);
int id_x = (r[0] - dom[0][0])/spacing;
int id_y = (r[1] - dom[1][0])/spacing;
if(id_x<0)
id_x = 0;
if(id_x>nx-1)
id_x = nx-1;
if(id_y<0)
id_y = 0;
if(id_y>ny-1)
id_y = ny-1;
if(holes[id_x][id_y]){
p_i->removePdParticle( con.first );
nRemoveBonds++;
continue;
}
}
}
}
}
}
#ifdef _OPENMP
# pragma omp parallel for schedule(runtime)
#endif
for(int i=0;i<domain.myGrid.size(); i++)
{
int gridId = domain.myGrid[i];
GridPoint * gridPoint = domain.grid[gridId];
for(Particle * p_i:gridPoint->getParticles())
{
p_i->updateState();
}
}
#endif
}
