void
APITestUtil::CombinedTests()
{
// now let's build a test object
NURBSSet nset;
Matrix3 mat;
mat.IdentityMatrix();
// build an independent point
int indPnt = MakeTestPoint(nset);
// now a constrained point
int ptPnt = MakeTestPointCPoint(nset, indPnt);
// build a cv curve
int cvCrv = MakeTestCVCurve(nset, mat);
// and a constrained point on that curve
int crvPnt = MakeTestCurveCPoint(nset, cvCrv);
// now a point curve
int ptCrv = MakeTestPointCurve(nset, mat);
// Blend the two curves
int blendCrv = MakeTestBlendCurve(nset, cvCrv, ptCrv);
// make an offset of the CV curve
int offCrv = MakeTestOffsetCurve(nset, cvCrv);
// make a Transform curve of the point curve
int xformCrv = MakeTestXFormCurve(nset, ptCrv);
// make a mirror of the blend
int mirCrv = MakeTestMirrorCurve(nset, blendCrv);
// make a fillet curve (It makes it's own point curves to fillet)
int fltCrv = MakeTestFilletCurve(nset);
// make a chamfer curve (It makes it's own point curves to fillet)
int chmCrv = MakeTestChamferCurve(nset);
// build a cv surface
int cvSurf = MakeTestCVSurface(nset, mat);
// and a constrained point on that surface
int srfPnt = MakeTestSurfCPoint(nset, cvSurf);
// Curve Surface intersection point.
int cvCrv2 = MakeTestCVCurve(nset, RotateXMatrix(PI/2.0f) * TransMatrix(Point3(0, 0, -175)));
int srfIntPoint = MakeTestCurveSurface(nset, cvSurf, cvCrv2);
// Now an Iso Curve on the CV surface
int isoCrv1 = MakeTestIsoCurveU(nset, cvSurf);
// Now an Iso Curve on the CV surface
int isoCrv2 = MakeTestIsoCurveV(nset, cvSurf);
// Now a Surface Edge Curve on the CV surface
int surfEdgeCrv = MakeTestSurfaceEdgeCurve(nset, cvSurf);
// build a CV Curve on Surface
int cvCOS = MakeTestCurveOnSurface(nset, cvSurf);
// build a Point Curve on Surface
int pntCOS = MakeTestPointCurveOnSurface(nset, cvSurf);
// build a Surface Normal Offset Curve
int cnoCrf = MakeTestSurfaceNormalCurve(nset, cvCOS);
// Make a curve-curve intersection point
int curveCurve = MakeTestCurveCurve(nset, isoCrv1, isoCrv2, TRUE);
// build a point surface
int ptSurf = MakeTestPointSurface(nset, mat);
// Blend the two surfaces
int blendSurf = MakeTestBlendSurface(nset, cvSurf, ptSurf);
// Offset of the blend
int offSurf = MakeTestOffsetSurface(nset, blendSurf);
// Transform of the Offset
int xformSurf = MakeTestXFormSurface(nset, offSurf);
// Mirror of the transform surface
int mirSurf = MakeTestMirrorSurface(nset, xformSurf);
// Make a Ruled surface between two curves
int rulSurf = MakeTestRuledSurface(nset, cvCrv, ptCrv);
// Make a ULoft surface
int uLoftSurf = MakeTestULoftSurface(nset, ptCrv, offCrv, xformCrv);
// Make a Extrude surface
int extSurf = MakeTestExtrudeSurface(nset, xformCrv);
// Make a lathe
int lthSurf = MakeTestLatheSurface(nset);
// these will build their own curves to work with
// UV Loft
int uvLoftSurf = MakeTestUVLoftSurface(nset);
// 1 Rail Sweep
int oneRailSurf = MakeTest1RailSweepSurface(nset);
// 2 Rail Sweep
int twoRailSurf = MakeTest2RailSweepSurface(nset);
// MultiCurveTrim Surface
int multiTrimSurf = MakeTestMultiCurveTrimSurface(nset);
// Now make the curves and surfaces that we'll use later for the join tests
int jc1, jc2, js1, js2;
AddObjectsForJoinTests(nset, jc1, jc2, js1, js2);
int bc, bs;
AddObjectsForBreakTests(nset, bc, bs);
Object *obj = CreateNURBSObject(mpIp, &nset, mat);
INode *node = mpIp->CreateObjectNode(obj);
node->SetName(GetString(IDS_TEST_OBJECT));
NURBSSet addNset;
// build a point surface
int addptSurf = AddTestPointSurface(addNset);
// add an iso curve to the previously created CV Surface
NURBSId id = nset.GetNURBSObject(cvSurf)->GetId();
int addIsoCrv = AddTestIsoCurve(addNset, id);
AddNURBSObjects(obj, mpIp, &addNset);
// now test some changing functionality
// Let's change the name of the CVSurface
NURBSObject* nObj = nset.GetNURBSObject(cvSurf);
nObj->SetName(_T("New CVSurf Name")); // testing only, no need to localize
// now let's change the position of one of the points in the point curve
NURBSPointCurve* ptCrvObj = (NURBSPointCurve*)nset.GetNURBSObject(ptCrv);
ptCrvObj->GetPoint(0)->SetPosition(0, Point3(10, 160, 0)); // moved from 0,150,0
// now let's change the position and weight of one of the CVs
// in the CV Surface
NURBSCVSurface* cvSurfObj = (NURBSCVSurface*)nset.GetNURBSObject(cvSurf);
cvSurfObj->GetCV(0, 0)->SetPosition(0, Point3(-150.0, -100.0, 20.0)); // moved from 0,0,0
cvSurfObj->GetCV(0, 0)->SetWeight(0, 2.0); // from 1.0
// now let's do a transform of a curve.
NURBSIdTab xfmTab;
NURBSId nid = nset.GetNURBSObject(jc1)->GetId();
xfmTab.Append(1, &nid);
Matrix3 xfmMat;
xfmMat = TransMatrix(Point3(10, 10, -10));
SetXFormPacket xPack(xfmMat);
NURBSResult res = Transform(obj, xfmTab, xPack, xfmMat, 0);
// Now let's Join two curves
NURBSId jc1id = nset.GetNURBSObject(jc1)->GetId(),
jc2id = nset.GetNURBSObject(jc2)->GetId();
JoinCurves(obj, jc1id, jc2id, FALSE, TRUE, 20.0, 1.0f, 1.0f, 0);
// Now let's Join two surfaces
NURBSId js1id = nset.GetNURBSObject(js1)->GetId(),
js2id = nset.GetNURBSObject(js2)->GetId();
JoinSurfaces(obj, js1id, js2id, 1, 0, 20.0, 1.0f, 1.0f, 0);
// Break a Curve
NURBSId bcid = nset.GetNURBSObject(bc)->GetId();
BreakCurve(obj, bcid, .5, 0);
// Break a Surface
NURBSId bsid = nset.GetNURBSObject(bs)->GetId();
BreakSurface(obj, bsid, TRUE, .5, 0);
mpIp->RedrawViews(mpIp->GetTime());
nset.DeleteObjects();
addNset.DeleteObjects();
// now do a detach
NURBSSet detset;
Matrix3 detmat;
detmat.IdentityMatrix();
// build a cv curve
int detcvCrv = MakeTestCVCurve(detset, detmat);
// now a point curve
int detptCrv = MakeTestPointCurve(detset, detmat);
// Blend the two curves
int detblendCrv = MakeTestBlendCurve(detset, detcvCrv, detptCrv);
Object *detobj = CreateNURBSObject(mpIp, &detset, detmat);
INode *detnode = mpIp->CreateObjectNode(detobj);
detnode->SetName("Detach From");
BOOL copy = TRUE;
BOOL relational = TRUE;
NURBSIdList detlist;
NURBSId oid = detset.GetNURBSObject(detblendCrv)->GetId();
detlist.Append(1, &oid);
DetachObjects(GetCOREInterface()->GetTime(), detnode, detobj,
detlist, "Detach Test", copy, relational);
mpIp->RedrawViews(mpIp->GetTime());
}
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;
}
