void ExtrudeMod::BuildPatchFromShape(TimeValue t,ModContext &mc, ObjectState * os, PatchMesh &pmesh) {
ShapeObject *shape = (ShapeObject *)os->obj;
float amount;
int levels,capStart,capEnd,capType;
pblock->GetValue(PB_AMOUNT,t,amount,FOREVER);
pblock->GetValue(PB_SEGS,t,levels,FOREVER);
if (levels<1) levels = 1;
pblock->GetValue(PB_CAPSTART,t,capStart,FOREVER);
pblock->GetValue(PB_CAPEND,t,capEnd,FOREVER);
pblock->GetValue(PB_CAPTYPE,t,capType,FOREVER);
BOOL texturing;
pblock->GetValue(PB_MAPPING, TimeValue(0), texturing, FOREVER);
BOOL genMatIDs;
pblock->GetValue(PB_GEN_MATIDS, TimeValue(0), genMatIDs, FOREVER);
BOOL useShapeIDs;
pblock->GetValue(PB_USE_SHAPEIDS, TimeValue(0), useShapeIDs, FOREVER);
BOOL smooth;
pblock->GetValue(PB_SMOOTH, TimeValue(0), smooth, FOREVER);
LimitValue(amount, -1000000.0f, 1000000.0f);
// Get the basic dimension stuff
float zSize = (float)fabs(amount);
float baseZ = 0.0f;
if(amount < 0.0f)
baseZ = amount;
// If the shape can convert itself to a BezierShape, have it do so!
BezierShape bShape;
if(shape->CanMakeBezier())
shape->MakeBezier(t, bShape);
else {
PolyShape pShape;
shape->MakePolyShape(t, pShape);
bShape = pShape; // UGH -- Convert it from a PolyShape -- not good!
}
//DebugPrint(_T("Extrude organizing shape\n"));
ShapeHierarchy hier;
bShape.OrganizeCurves(t, &hier);
// Need to flip the reversed polys...
bShape.Reverse(hier.reverse);
// ...and tell the hierarchy they're no longer reversed!
hier.reverse.ClearAll();
// Our shapes are now organized for patch-making -- Let's do the sides!
int polys = bShape.splineCount;
int poly, knot;
int levelVerts = 0, levelVecs = 0, levelPatches = 0, nverts = 0, nvecs = 0, npatches = 0;
int TVlevels = levels + 1, levelTVerts = 0, ntverts = 0, ntpatches = 0;
BOOL anyClosed = FALSE;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
if(spline->Closed())
anyClosed = TRUE;
levelVerts += spline->KnotCount();
levelTVerts += (spline->Segments() + 1);
levelVecs += (spline->Segments() * 2);
levelPatches += spline->Segments();
}
nverts = levelVerts * (levels + 1);
npatches = levelPatches * levels;
nvecs = (levelVecs * (levels + 1)) + levels * levelVerts * 2 + npatches * 4;
if(texturing) {
ntverts = levelTVerts * TVlevels;
ntpatches = npatches;
}
pmesh.setNumVerts(nverts);
pmesh.setNumVecs(nvecs);
pmesh.setNumPatches(npatches);
pmesh.setNumTVerts(ntverts);
pmesh.setNumTVPatches(ntpatches);
// Create the vertices!
int vert = 0;
int level;
Point3 offset1, offset2;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
int knots = spline->KnotCount();
for(level = 0; level <= levels; ++level) {
Point3 offset = Point3(0.0f, 0.0f, baseZ + (float)level / (float)levels * zSize);
if(level == 0)
offset1 = offset;
else
if(level == levels)
offset2 = offset;
for(knot = 0; knot < knots; ++knot) {
Point3 p = spline->GetKnotPoint(knot);
pmesh.setVert(vert++, p + offset);
}
}
}
assert(vert == nverts);
BOOL usePhysUVs = GetUsePhysicalScaleUVs();
// Maybe create the texture vertices
if(texturing) {
int tvert = 0;
int level;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
// Make it a polyline
PolyLine pline;
spline->MakePolyLine(pline, 10);
int knots = spline->KnotCount();
for(level = 0; level < TVlevels; ++level) {
float tV = (float)level / (float)(TVlevels - 1);
float vScale = usePhysUVs ? amount : 1.0f;
int lverts = pline.numPts;
int tp = 0;
int texPts = spline->Segments() + 1;
float cumLen = 0.0f;
float totLen = pline.CurveLength();
float uScale = usePhysUVs ? totLen : 1.0f;
Point3 prevPt = pline.pts[0].p;
int plix = 0;
while(tp < texPts) {
Point3 &pt = pline[plix].p;
cumLen += Length(pt - prevPt);
prevPt = pt;
if(pline[plix].flags & POLYPT_KNOT) {
float tU;
if(tp == (texPts - 1))
tU = 1.0f;
else
tU = cumLen / totLen;
pmesh.setTVert(tvert++, UVVert(uScale*tU, vScale*tV, 0.0f));
tp++;
}
plix = (plix + 1) % pline.numPts;
}
}
}
assert(tvert == ntverts);
}
// Create the vectors!
int seg;
int vec = 0;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
int segs = spline->Segments();
int knots = spline->KnotCount();
// First, the vectors on each level
for(level = 0; level <= levels; ++level) {
Point3 offset = Point3(0.0f, 0.0f, baseZ + (float)level / (float)levels * zSize);
for(seg = 0; seg < segs; ++seg) {
int seg2 = (seg + 1) % knots;
if(spline->GetLineType(seg) == LTYPE_CURVE) {
Point3 p = spline->GetOutVec(seg);
pmesh.setVec(vec++, p + offset);
p = spline->GetInVec(seg2);
pmesh.setVec(vec++, p + offset);
}
else {
Point3 p = spline->InterpBezier3D(seg, 0.333333f);
pmesh.setVec(vec++, p + offset);
p = spline->InterpBezier3D(seg, 0.666666f);
pmesh.setVec(vec++, p + offset);
}
}
}
// Now, the vectors between the levels
int baseVec = vec;
for(level = 0; level < levels; ++level) {
Point3 offsetA = Point3(0.0f, 0.0f, baseZ + (float)level / (float)levels * zSize);
Point3 offsetB = Point3(0.0f, 0.0f, baseZ + (float)(level + 1) / (float)levels * zSize);
Point3 offset1 = offsetA + (offsetB - offsetA) * 0.333333333f;
Point3 offset2 = offsetA + (offsetB - offsetA) * 0.666666666f;
for(knot = 0; knot < knots; ++knot) {
Point3 p = spline->GetKnotPoint(knot);
pmesh.setVec(vec++, p + offset1);
pmesh.setVec(vec++, p + offset2);
}
}
}
// Create the patches!
int np = 0;
int baseVert = 0;
int baseVec = 0;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
int knots = spline->KnotCount();
int segs = spline->Segments();
int baseVec1 = baseVec; // Base vector index for this level
int baseVec2 = baseVec + segs * 2 * (levels + 1); // Base vector index for between levels
for(level = 0; level < levels; ++level) {
int sm = 0;
BOOL firstSmooth = (spline->GetLineType(0) == LTYPE_CURVE && spline->GetLineType(segs-1) == LTYPE_CURVE && (spline->GetKnotType(0) == KTYPE_AUTO || spline->GetKnotType(0) == KTYPE_BEZIER)) ? TRUE : FALSE;
for(seg = 0; seg < segs; ++seg, vec += 4) {
int prevseg = (seg + segs - 1) % segs;
int seg2 = (seg + 1) % knots;
int a,b,c,d,ab,ba,bc,cb,cd,dc,da,ad;
MtlID mtl = useShapeIDs ? spline->GetMatID(seg) : 2;
a = baseVert + seg;
b = baseVert + seg2;
c = b + knots;
d = a + knots;
ab = baseVec1 + seg * 2;
ba = ab + 1;
bc = baseVec2 + seg2 * 2;
cb = bc + 1;
cd = ba + (segs * 2);
dc = ab + (segs * 2);
da = baseVec2 + seg * 2 + 1;
ad = da - 1;
//DebugPrint(_T("Making patch %d: %d (%d %d) %d (%d %d) %d (%d %d) %d (%d %d)\n"),np, a, ab, ba, b, bc, cb, c, cd, dc, d, da, ad);
// If the vertex is not smooth, go to the next group!
if(seg > 0 && !(spline->GetLineType(prevseg) == LTYPE_CURVE && spline->GetLineType(seg) == LTYPE_CURVE && (spline->GetKnotType(seg) == KTYPE_AUTO || spline->GetKnotType(seg) == KTYPE_BEZIER))) {
sm++;
if(sm > 2)
sm = 1;
}
DWORD smoothGroup = 1 << sm;
if(seg == segs - 1 && firstSmooth) {
smoothGroup |= 1;
}
pmesh.MakeQuadPatch(np, a, ab, ba, b, bc, cb, c, cd, dc, d, da, ad, vec, vec+1, vec+2, vec+3, smooth ? smoothGroup : 0);
pmesh.setPatchMtlIndex(np++, genMatIDs ? mtl : 0);
}
baseVert += knots;
baseVec1 += (segs * 2);
baseVec2 += (knots * 2);
}
baseVert += knots;
baseVec += (segs * 2 * (levels + 1) + knots * 2 * levels);
}
assert(vec == nvecs);
assert(np == npatches);
// Maybe create the texture patches!
if(texturing) {
int ntp = 0;
int baseTVert = 0;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
int pknots = spline->Segments() + 1;
int pverts = pknots * TVlevels;
int segs = spline->Segments();
for(level = 0; level < levels; ++level) {
for(seg = 0; seg < segs; ++seg) {
int prevseg = (seg + segs - 1) % segs;
int seg2 = seg + 1;
int a,b,c,d;
a = baseTVert + seg;
b = baseTVert + seg2;
c = b + pknots;
d = a + pknots;
TVPatch &tp = pmesh.getTVPatch(ntp++);
tp.setTVerts(a, b, c, d);
}
baseTVert += pknots;
}
baseTVert += pknots;
}
assert(ntp == ntpatches);
}
// If capping, do it!
if(anyClosed && (capStart || capEnd)) {
PatchCapInfo capInfo;
bShape.MakeCap(t, capInfo);
// Build information for capping
PatchCapper capper(bShape);
if(capStart) {
vert = 0;
int baseVec = 0;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
PatchCapPoly &capline = capper[poly];
int lverts = spline->KnotCount();
for(int v = 0; v < lverts; ++v)
capline.SetVert(v, vert++); // Gives this vert's location in the mesh!
vert += lverts * levels;
vec = baseVec;
int lvecs = spline->Segments() * 2;
for(int v = 0; v < lvecs; ++v)
capline.SetVec(v, vec++); // Gives this vec's location in the mesh!
baseVec += lvecs * (levels + 1) + spline->KnotCount() * levels * 2;
}
// Create a work matrix for capping
Matrix3 mat = TransMatrix(offset1);
int oldPatches = pmesh.numPatches;
capper.CapPatchMesh(pmesh, capInfo, TRUE, 16, &mat, genMatIDs ? -1 : 0);
// If texturing, create the texture patches and vertices
if(texturing)
MakePatchCapTexture(pmesh, Inverse(mat), oldPatches, pmesh.numPatches, usePhysUVs);
}
if(capEnd) {
int baseVert = 0;
int baseVec = 0;
for(poly = 0; poly < polys; ++poly) {
Spline3D *spline = bShape.splines[poly];
if(!spline->KnotCount())
continue;
PatchCapPoly &capline = capper[poly];
int lverts = spline->KnotCount();
int vert = baseVert + lverts * levels;
for(int v = 0; v < lverts; ++v)
capline.SetVert(v, vert++); // Gives this vert's location in the mesh!
baseVert += lverts * (levels + 1);
int lvecs = spline->Segments()*2;
int vec = baseVec + lvecs * levels;
for(int v = 0; v < lvecs; ++v)
capline.SetVec(v, vec++); // Gives this vec's location in the mesh!
baseVec += lvecs * (levels + 1) + spline->KnotCount() * levels * 2;
}
// Create a work matrix for grid capping
Matrix3 mat = TransMatrix(offset2);
int oldPatches = pmesh.numPatches;
capper.CapPatchMesh(pmesh, capInfo, FALSE, 16, &mat, genMatIDs ? -1 : 0);
// If texturing, create the texture patches and vertices
if(texturing)
MakePatchCapTexture(pmesh, Inverse(mat), oldPatches, pmesh.numPatches, usePhysUVs);
}
}
//watje new mapping
if(texturing)
{
if (ver < 4)
{
for (int i = 0; i < pmesh.numPatches; i++)
pmesh.patches[i].flags |= PATCH_LINEARMAPPING;
}
}
// Ready the patch representation!
if( !pmesh.buildLinkages() )
{
assert(0);
}
pmesh.computeInteriors();
}
bool AlembicCurves::Save(double time, bool bLastFrame)
{
ESS_PROFILE_FUNC();
//TimeValue ticks = GET_MAX_INTERFACE()->GetTime();
TimeValue ticks = GetTimeValueFromFrame(time);
Object *obj = mMaxNode->EvalWorldState(ticks).obj;
if(mNumSamples == 0){
bForever = CheckIfObjIsValidForever(obj, ticks);
}
else{
bool bNewForever = CheckIfObjIsValidForever(obj, ticks);
if(bForever && bNewForever != bForever){
ESS_LOG_INFO( "bForever has changed" );
}
}
SaveMetaData(mMaxNode, this);
// check if the spline is animated
if(mNumSamples > 0)
{
if(bForever)
{
return true;
}
}
AbcG::OCurvesSchema::Sample curvesSample;
std::vector<AbcA::int32_t> nbVertices;
std::vector<Point3> vertices;
std::vector<float> knotVector;
std::vector<Abc::uint16_t> orders;
if(obj->ClassID() == EDITABLE_SURF_CLASS_ID){
NURBSSet nurbsSet;
BOOL success = GetNURBSSet(obj, ticks, nurbsSet, TRUE);
AbcG::CurvePeriodicity cPeriod = AbcG::kNonPeriodic;
AbcG::CurveType cType = AbcG::kCubic;
AbcG::BasisType cBasis = AbcG::kNoBasis;
int n = nurbsSet.GetNumObjects();
for(int i=0; i<n; i++){
NURBSObject* pObject = nurbsSet.GetNURBSObject((int)i);
//NURBSType type = pObject->GetType();
if(!pObject){
continue;
}
if( pObject->GetKind() == kNURBSCurve ){
NURBSCurve* pNurbsCurve = (NURBSCurve*)pObject;
int degree;
int numCVs;
NURBSCVTab cvs;
int numKnots;
NURBSKnotTab knots;
pNurbsCurve->GetNURBSData(ticks, degree, numCVs, cvs, numKnots, knots);
orders.push_back(degree+1);
const int cvsCount = cvs.Count();
const int knotCount = knots.Count();
for(int j=0; j<cvs.Count(); j++){
NURBSControlVertex cv = cvs[j];
double x, y, z;
cv.GetPosition(ticks, x, y, z);
vertices.push_back( Point3((float)x, (float)y, (float)z) );
}
nbVertices.push_back(cvsCount);
//skip the first and last entry because Maya and XSI use this format
for(int j=1; j<knots.Count()-1; j++){
knotVector.push_back((float)knots[j]);
}
if(i == 0){
if(pNurbsCurve->IsClosed()){
cPeriod = AbcG::kPeriodic;
}
}
else{
if(pNurbsCurve->IsClosed()){
if(cPeriod != AbcG::kPeriodic){
ESS_LOG_WARNING("Mixed curve wrap types not supported.");
}
}
else{
if(cPeriod != AbcG::kNonPeriodic){
ESS_LOG_WARNING("Mixed curve wrap types not supported.");
}
}
}
}
}
curvesSample.setType(cType);
curvesSample.setWrap(cPeriod);
curvesSample.setBasis(cBasis);
}
else
{
BezierShape beziershape;
PolyShape polyShape;
bool bBezier = false;
// Get a pointer to the spline shpae
ShapeObject *pShapeObject = NULL;
if (obj->IsShapeObject())
{
pShapeObject = reinterpret_cast<ShapeObject *>(obj);
}
else
{
return false;
}
// Determine if we are a bezier shape
if (pShapeObject->CanMakeBezier())
{
pShapeObject->MakeBezier(ticks, beziershape);
bBezier = true;
}
else
{
pShapeObject->MakePolyShape(ticks, polyShape);
bBezier = false;
}
// Get the control points
//std::vector<Point3> inTangents;
//std::vector<Point3> outTangents;
if (bBezier)
{
int oldVerticesCount = (int)vertices.size();
for (int i = 0; i < beziershape.SplineCount(); i += 1)
{
Spline3D *pSpline = beziershape.GetSpline(i);
int knots = pSpline->KnotCount();
for(int ix = 0; ix < knots; ++ix)
{
Point3 in = pSpline->GetInVec(ix);
Point3 p = pSpline->GetKnotPoint(ix);
Point3 out = pSpline->GetOutVec(ix);
vertices.push_back( p );
//inTangents.push_back( in );
//outTangents.push_back( out );
}
int nNumVerticesAdded = (int)vertices.size() - oldVerticesCount;
nbVertices.push_back( nNumVerticesAdded );
oldVerticesCount = (int)vertices.size();
}
}
else
{
for (int i = 0; i < polyShape.numLines; i += 1)
{
PolyLine &refLine = polyShape.lines[i];
nbVertices.push_back(refLine.numPts);
for (int j = 0; j < refLine.numPts; j += 1)
{
Point3 p = refLine.pts[j].p;
vertices.push_back(p);
}
}
}
// set the type + wrapping
curvesSample.setType(bBezier ? AbcG::kCubic : AbcG::kLinear);
curvesSample.setWrap(pShapeObject->CurveClosed(ticks, 0) ? AbcG::kPeriodic : AbcG::kNonPeriodic);
curvesSample.setBasis(AbcG::kNoBasis);
}
if(nbVertices.size() == 0 || vertices.size() == 0){
ESS_LOG_WARNING("No curve data to export.");
return false;
}
const int vertCount = (int)vertices.size();
// prepare the bounding box
Abc::Box3d bbox;
// allocate the points and normals
std::vector<Abc::V3f> posVec(vertCount);
Matrix3 wm = mMaxNode->GetObjTMAfterWSM(ticks);
for(int i=0;i<vertCount;i++)
{
posVec[i] = ConvertMaxPointToAlembicPoint(vertices[i] );
bbox.extendBy(posVec[i]);
// Set the archive bounding box
if (mJob)
{
Point3 worldMaxPoint = wm * vertices[i];
Abc::V3f alembicWorldPoint = ConvertMaxPointToAlembicPoint(worldMaxPoint);
mJob->GetArchiveBBox().extendBy(alembicWorldPoint);
}
}
if(knotVector.size() > 0 && orders.size() > 0){
if(!mKnotVectorProperty.valid()){
mKnotVectorProperty = Abc::OFloatArrayProperty(mCurvesSchema.getArbGeomParams(), ".knot_vector", mCurvesSchema.getMetaData(), mJob->GetAnimatedTs() );
}
mKnotVectorProperty.set(Abc::FloatArraySample(knotVector));
if(!mOrdersProperty.valid()){
mOrdersProperty = Abc::OUInt16ArrayProperty(mCurvesSchema.getArbGeomParams(), ".orders", mCurvesSchema.getMetaData(), mJob->GetAnimatedTs() );
}
mOrdersProperty.set(Abc::UInt16ArraySample(orders));
}
// store the bbox
curvesSample.setSelfBounds(bbox);
mCurvesSchema.getChildBoundsProperty().set(bbox);
Abc::Int32ArraySample nbVerticesSample(&nbVertices.front(),nbVertices.size());
curvesSample.setCurvesNumVertices(nbVerticesSample);
// allocate for the points and normals
Abc::P3fArraySample posSample(&posVec.front(),posVec.size());
curvesSample.setPositions(posSample);
mCurvesSchema.set(curvesSample);
mNumSamples++;
return true;
}
void MirrorMod::ModifyObject(
TimeValue t, ModContext &mc, ObjectState *os, INode *node)
{
Matrix3 itm = CompMatrix(t,NULL,&mc);
Matrix3 tm = Inverse(itm);
Interval iv = FOREVER;
int axis, copy;
float offset;
pblock->GetValue(PB_AXIS,t,axis,iv);
pblock->GetValue(PB_COPY,t,copy,iv);
pblock->GetValue(PB_OFFSET,t,offset,iv);
DWORD oldLevel;
BOOL convertedShape = FALSE;
BitArray oldFaceSelections;
// support for TriObjects
if (os->obj->IsSubClassOf(triObjectClassID)) {
TriObject *tobj = (TriObject*)os->obj;
Mesh &mesh = tobj->GetMesh();
switch (mesh.selLevel) {
case MESH_OBJECT: mesh.faceSel.SetAll(); break;
case MESH_VERTEX: {
for (int i=0; i<mesh.getNumFaces(); i++) {
for (int j=0; j<3; j++) {
if (mesh.vertSel[mesh.faces[i].v[j]]) {
mesh.faceSel.Set(i);
}
}
}
break;
}
case MESH_EDGE: {
for (int i=0; i<mesh.getNumFaces(); i++) {
for (int j=0; j<3; j++) {
if (mesh.edgeSel[i*3+j]) {
mesh.faceSel.Set(i);
}
}
}
break;
}
}
oldLevel = mesh.selLevel;
mesh.selLevel = MESH_FACE;
if (copy) {
mesh.CloneFaces(mesh.faceSel);
mesh.ClearVSelectionWeights ();
}
if (axis<3) {
for (int i=0; i<mesh.getNumFaces(); i++) {
if (mesh.faceSel[i]) mesh.FlipNormal(i);
}
}
}
#ifndef NO_PATCHES
// support for PatchObjects
if (os->obj->IsSubClassOf(patchObjectClassID)) {
PatchObject *pobj = (PatchObject*)os->obj;
PatchMesh &pmesh = pobj->GetPatchMesh(t);
switch (pmesh.selLevel) {
case PATCH_OBJECT: pmesh.patchSel.SetAll(); break;
case PATCH_VERTEX: {
for (int i=0; i<pmesh.getNumPatches(); i++) {
Patch &p = pmesh.patches[i];
for (int j=0; j<p.type; j++) {
if (pmesh.vertSel[p.v[j]]) {
pmesh.patchSel.Set(i);
break;
}
}
}
break;
}
case PATCH_EDGE: {
for (int i=0; i<pmesh.getNumPatches(); i++) {
Patch &p = pmesh.patches[i];
for (int j=0; j<p.type; j++) {
if (pmesh.edgeSel[p.edge[j]]) {
pmesh.patchSel.Set(i);
break;
}
}
}
break;
}
}
oldLevel = pmesh.selLevel;
pmesh.selLevel = PATCH_PATCH;
if (copy)
pmesh.ClonePatchParts(); // Copy the selected patches
if (axis<3)
pmesh.FlipPatchNormal(-1); // Flip selected normals
}
#endif // NO_PATCHES
// support for PolyObjects
else if (os->obj->IsSubClassOf(polyObjectClassID)) {
PolyObject * pPolyOb = (PolyObject*)os->obj;
MNMesh &mesh = pPolyOb->GetMesh();
// Luna task 747
// We don't support specified normals here because it would take special code
mesh.ClearSpecifiedNormals ();
BitArray faceSelections;
mesh.getFaceSel (faceSelections);
switch (mesh.selLevel) {
case MNM_SL_OBJECT: faceSelections.SetAll(); break;
case MNM_SL_VERTEX: {
faceSelections.ClearAll ();
for (int i=0; i<mesh.FNum(); i++) {
for (int j=0; j<mesh.F(i)->deg; j++) {
int vertIndex = mesh.F(i)->vtx[j];
if (mesh.V(vertIndex)->GetFlag(MN_SEL)) {
faceSelections.Set(i);
break;
}
}
}
break;
}
case MNM_SL_EDGE: {
faceSelections.ClearAll ();
for (int i=0; i<mesh.FNum(); i++) {
for (int j=0; j<mesh.F(i)->deg; j++) {
int edgeIndex = mesh.F(i)->edg[j];
if (mesh.E(edgeIndex)->GetFlag(MN_SEL)) {
faceSelections.Set(i);
break;
}
}
}
break;
}
}
// preserve the existing selection settings
oldLevel = mesh.selLevel;
mesh.getFaceSel (oldFaceSelections);
// set the face selections
mesh.ClearFFlags (MN_SEL);
mesh.FaceSelect(faceSelections);
mesh.selLevel = MNM_SL_FACE;
// copy the selected faces and flip Normal direction as needed
if (copy) {
mesh.CloneFaces();
mesh.freeVSelectionWeights ();
}
// Now, note that by PolyMesh rules, we can only flip entire selected elements.
// So we broaden our selection to include entire elements that are only partially selected:
for (int i=0; i<mesh.numf; i++) {
if (mesh.f[i].GetFlag (MN_DEAD)) continue;
if (!mesh.f[i].GetFlag (MN_SEL)) continue;
mesh.PaintFaceFlag (i, MN_SEL);
}
if (axis<3) {
for (i=0; i<mesh.FNum(); i++) {
if (mesh.F(i)->GetFlag(MN_SEL)) mesh.FlipNormal(i);
}
if (mesh.GetFlag (MN_MESH_FILLED_IN)) {
// We also need to flip edge normals:
for (i=0; i<mesh.ENum(); i++) {
if (mesh.f[mesh.e[i].f1].GetFlag (MN_SEL)) {
int hold = mesh.e[i].v1;
mesh.e[i].v1 = mesh.e[i].v2;
mesh.e[i].v2 = hold;
}
}
}
}
}
// support for shape objects
else
if (os->obj->IsSubClassOf(splineShapeClassID)) {
SplineShape *ss = (SplineShape*)os->obj;
BezierShape &shape = ss->shape;
oldLevel = shape.selLevel;
switch (shape.selLevel) {
case SHAPE_OBJECT:
case SHAPE_VERTEX:
shape.selLevel = SHAPE_SPLINE;
shape.polySel.SetAll();
break;
case SHAPE_SPLINE:
case SHAPE_SEGMENT:
break;
}
if (copy)
shape.CloneSelectedParts((axis < 3 && splineMethod == SPLINE_REVERSE) ? TRUE : FALSE);
}
else
if(os->obj->SuperClassID() == SHAPE_CLASS_ID) {
ShapeObject *so = (ShapeObject *)os->obj;
if(so->CanMakeBezier()) {
SplineShape *ss = new SplineShape();
so->MakeBezier(t, ss->shape);
ss->SetChannelValidity(GEOM_CHAN_NUM, GetValidity(t) & so->ObjectValidity(t));
os->obj = ss;
os->obj->UnlockObject();
convertedShape = TRUE;
BezierShape &shape = ss->shape;
oldLevel = shape.selLevel;
switch (shape.selLevel) {
case SHAPE_OBJECT:
case SHAPE_VERTEX:
shape.selLevel = SHAPE_SPLINE;
shape.polySel.SetAll();
break;
case SHAPE_SPLINE:
case SHAPE_SEGMENT:
break;
}
if (copy)
shape.CloneSelectedParts((axis < 3 && splineMethod == SPLINE_REVERSE) ? TRUE : FALSE);
}
}
MirrorDeformer deformer(axis,offset,tm,itm);
os->obj->Deform(&deformer, TRUE);
// if (axis < 3 && splineMethod == SPLINE_REVERSE)
{
if (os->obj->IsSubClassOf(splineShapeClassID)) {
SplineShape *ss = (SplineShape*)os->obj;
BezierShape &shape = ss->shape;
for (int i = 0; i < shape.bindList.Count(); i++)
{
int index = 0;
int spindex = shape.bindList[i].pointSplineIndex;
// Point3 p=shape.splines[spindex]->GetKnot(index).Knot();
if (shape.bindList[i].isEnd)
index = shape.splines[spindex]->KnotCount()-1;
shape.bindList[i].bindPoint = shape.splines[spindex]->GetKnotPoint(index);
shape.bindList[i].segPoint = shape.splines[spindex]->GetKnotPoint(index);
}
shape.UpdateBindList(TRUE);
}
else
if(os->obj->SuperClassID() == SHAPE_CLASS_ID) {
ShapeObject *so = (ShapeObject *)os->obj;
if(so->CanMakeBezier()) {
SplineShape *ss = new SplineShape();
so->MakeBezier(t, ss->shape);
ss->SetChannelValidity(GEOM_CHAN_NUM, GetValidity(t) & so->ObjectValidity(t));
os->obj = ss;
os->obj->UnlockObject();
convertedShape = TRUE;
BezierShape &shape = ss->shape;
for (int i = 0; i < shape.bindList.Count(); i++)
{
int index = 0;
int spindex = shape.bindList[i].pointSplineIndex;
// Point3 p;
if (shape.bindList[i].isEnd)
index = shape.splines[spindex]->KnotCount()-1;
shape.bindList[i].bindPoint = shape.splines[spindex]->GetKnotPoint(index);
shape.bindList[i].segPoint = shape.splines[spindex]->GetKnotPoint(index);
}
shape.UpdateBindList(TRUE);
}
}
}
os->obj->UpdateValidity(GEOM_CHAN_NUM,GetValidity(t));
// restore the original selections
if (os->obj->IsSubClassOf(triObjectClassID)) {
TriObject *tobj = (TriObject*)os->obj;
tobj->GetMesh().selLevel = oldLevel;
}
#ifndef NO_PATCHES
else if (os->obj->IsSubClassOf(patchObjectClassID)) {
PatchObject *pobj = (PatchObject*)os->obj;
pobj->GetPatchMesh(t).selLevel = oldLevel;
}
#endif // NO_PATCHES
else if (os->obj->IsSubClassOf(polyObjectClassID)) {
PolyObject *pPolyOb = (PolyObject*)os->obj;
pPolyOb->GetMesh().selLevel = oldLevel;
pPolyOb->GetMesh().dispFlags = 0;
switch (oldLevel) {
case MNM_SL_VERTEX:
pPolyOb->GetMesh().dispFlags = MNDISP_SELVERTS | MNDISP_VERTTICKS;
break;
case MNM_SL_EDGE:
pPolyOb->GetMesh().dispFlags = MNDISP_SELEDGES;
break;
case MNM_SL_FACE:
pPolyOb->GetMesh().dispFlags = MNDISP_SELFACES;
break;
}
pPolyOb->GetMesh().FaceSelect(oldFaceSelections);
}
else
if(os->obj->IsSubClassOf(splineShapeClassID) || convertedShape) {
SplineShape *ss = (SplineShape*)os->obj;
ss->shape.selLevel = oldLevel;
}
}
