MBoundingBox kgLocator::boundingBox() const
{
MBoundingBox bbox;
MPoint pt;
MStatus stat;
MObject thisNode = thisMObject();
MFnDagNode dagFn( thisNode );
MPlug heightPlug = dagFn.findPlug( height, &stat );
float heightValue;
heightPlug.getValue( heightValue );
for(unsigned int i=0; i < pts.length(); ++i )
{
pt.x = pts[i].x; pt.y = pts[i].y; pt.z = pts[i].z;
bbox.expand( pt );
}
//account for the vertical spindle
pt.x=0.0; pt.y = 0.0f; pt.z = 0.0f;
bbox.expand( pt );
pt.x=0.0; pt.y = heightValue; pt.z = 0.0f;
bbox.expand( pt );
return bbox;
}
MStatus ffdPlanar::getBoundingBox( MDataBlock& block,
unsigned int multiIndex,
MBoundingBox &boundingBoxOut )
{
MStatus status = MS::kSuccess;
MArrayDataHandle inputHandle = block.outputArrayValue( input );
inputHandle.jumpToElement( multiIndex );
MObject mesh = inputHandle.outputValue().child( inputGeom ).asMesh();
MBoundingBox boundingBox = MBoundingBox();
MFnMesh meshFn( mesh, &status );
MCheckErr( status, "Error getting mesh from mesh object\n" );
MPointArray pointArray = MPointArray();
meshFn.getPoints( pointArray, MSpace::kTransform );
for ( int i = 0; i < pointArray.length(); i++ )
{
boundingBox.expand( pointArray[i] );
}
boundingBoxOut = boundingBox;
return status;
}
void AbcWriteJob::perFrameCallback(double iFrame)
{
MBoundingBox bbox;
util::ShapeSet::iterator it = mArgs.dagPaths.begin();
const util::ShapeSet::iterator end = mArgs.dagPaths.end();
for (; it != end; it ++)
{
mCurDag = *it;
MMatrix eMInvMat;
if (mArgs.worldSpace)
{
eMInvMat.setToIdentity();
}
else
{
eMInvMat = mCurDag.exclusiveMatrixInverse();
}
bbox.expand(getBoundingBox(iFrame, eMInvMat));
}
Alembic::Abc::V3d min(bbox.min().x, bbox.min().y, bbox.min().z);
Alembic::Abc::V3d max(bbox.max().x, bbox.max().y, bbox.max().z);
Alembic::Abc::Box3d b(min, max);
mBoxProp.set(b);
processCallback(mArgs.melPerFrameCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPerFrameCallback, false, iFrame, bbox);
}
MBoundingBox curvedArrows::boundingBox() const
{
MBoundingBox bbox;
unsigned int i;
for ( i = 0; i < fsVertexListSize; i ++ ) {
double *pt = fsVertexList[i];
bbox.expand( MPoint( pt[0], pt[1], pt[2] ) );
}
return bbox;
}
void SpatialGrid::expandBBoxByPercentage(
MBoundingBox& bbox,
double percentage,
double min[3]
)
//
// Description:
//
// Expands the given bounding box by the given percentage
// in all dimensions. Percentage should be a value between
// 0 and 1, representing 0% to 100%.
//
// The optional 3 "min" values specify minimum sizes along each
// axis that the bounding box size will be expanded to. This
// is useful for situations where one of the box axes is so small
// that a percentagewise increase will not be meaningful.
//
{
percentage += 1.0;
MPoint c = bbox.center();
float w = bbox.width();
float h = bbox.height();
float d = bbox.depth();
// clamp the box sizes to the minimums, if given
//
if( min != NULL )
{
if( w < min[0] )
{
w = min[0];
}
if( h < min[1] )
{
h = min[1];
}
if( d < min[2] )
{
d = min[2];
}
}
// increase the box size
//
MVector offset(w, h, d);
offset *= (0.5f * percentage);
bbox.expand( c + offset);
bbox.expand( c - offset);
}
MBoundingBox sphericalBlendShapeVisualizerDrawOverride::boundingBox(
const MDagPath& objPath,
const MDagPath& cameraPath) const
{
MBoundingBox bbox;
double radius = 1.0;
MMatrix spaceMatrix = getSpaceMatrix(objPath);
/*for(unsigned int i=0; i<bboxPoints.length(); i++) {
bbox.expand(bboxPoints[i]);
}*/
bbox.expand(MPoint(-radius, 0.0, 0.0) * spaceMatrix);
bbox.expand(MPoint(radius, 0.0, 0.0) * spaceMatrix);
bbox.expand(MPoint(0.0, -radius, 0.0) * spaceMatrix);
bbox.expand(MPoint(0.0, radius, 0.0) * spaceMatrix);
bbox.expand(MPoint(0.0, 0.0, -radius) * spaceMatrix);
bbox.expand(MPoint(0.0, 0.0, radius) * spaceMatrix);
return bbox;
}
MBoundingBox BasicLocator::boundingBox() const
//
// N.B. It is important to have this bounding box function otherwise zoom selected and
// zoom all won't work correctly.
//
{
MPointArray pts;
getCirclePoints( pts );
MBoundingBox bbox;
for( unsigned int i=0; i < pts.length(); i++ )
bbox.expand( pts[i] );
return bbox;
}
MBoundingBox ovalLocator::boundingbox (float multiplier /*=1.0f*/) {
static MBoundingBox boundingbox ;
if ( boundingbox.min () == boundingbox.max () ) {
MPointArray vert =ovalLocator::vertices () ;
for ( unsigned int i =0 ; i < vert.length () ; i++ )
boundingbox.expand (vert [i]) ;
}
MBoundingBox bbox (boundingbox) ;
if ( multiplier != 1.0f ) {
double factors [3] ={ multiplier, multiplier, multiplier } ;
MTransformationMatrix mat ;
mat.setScale (factors, MSpace::kWorld) ;
bbox.transformUsing (mat.asScaleMatrix ()) ;
}
return (bbox) ;
}
MBoundingBox BasicLocator::boundingBox() const
{
MBoundingBox bbox;
MFloatPointArray points;
points.clear();
points.setSizeIncrement(4);
points.append(-1.0, 0.0, 0.0);
points.append(1.0, 0.0, 0.0);
points.append(0.0, 0.0, 1.0);
points.append(0.0, 0.0, -1.0);
for (unsigned int i = 0; i < points.length(); i++)
bbox.expand(points[i]);
return bbox;
}
bool SGTransformManip::build()
{
SGIntersectResult& result = generalResult[0];
if (result.resultType != SGComponentType::kNone) {
intersector.intersectPoint = result.intersectPoint;
}
m_selVertices = SGSelection::getIndices( SGSelection::sels.getSelVtxIndicesMap() );
if (!m_selVertices.length()) return false;
SGMesh* pMesh = SGMesh::pMesh;
MBoundingBox bb;
for (unsigned int i = 0; i < m_selVertices.length(); i++) {
MPoint& targetPoint = pMesh->points[m_selVertices[i]];
pMesh->isCenter(m_selVertices[i], SGComponentType::kVertex);
if( !pMesh->isCenter(m_selVertices[i], SGComponentType::kVertex ) &&
SGToolCondition::option.symInfo.compairIsMirror( intersector.intersectPoint, targetPoint ) ) continue;
bb.expand(targetPoint);
}
MPoint bbCenter = bb.center();
if (SGSpace::space == MSpace::kObject) {
bbCenter *= pMesh->dagPath.inclusiveMatrix();
}
MMatrix mtx;
mtx(3, 0) = bbCenter.x;
mtx(3, 1) = bbCenter.y;
mtx(3, 2) = bbCenter.z;
intersector.build( mtx );
intersectType = SGTransformManipIntersector::kCenter;
updateCenter();
return true;
}
// write the frame ranges and statistic string on the root
// Also call the post callbacks
void AbcWriteJob::postCallback(double iFrame)
{
std::string statsStr = "";
addToString(statsStr, "SubDStaticNum", mStats.mSubDStaticNum);
addToString(statsStr, "SubDAnimNum", mStats.mSubDAnimNum);
addToString(statsStr, "SubDStaticCVs", mStats.mSubDStaticCVs);
addToString(statsStr, "SubDAnimCVs", mStats.mSubDAnimCVs);
addToString(statsStr, "SubDStaticFaces", mStats.mSubDStaticFaces);
addToString(statsStr, "SubDAnimFaces", mStats.mSubDAnimFaces);
addToString(statsStr, "PolyStaticNum", mStats.mPolyStaticNum);
addToString(statsStr, "PolyAnimNum", mStats.mPolyAnimNum);
addToString(statsStr, "PolyStaticCVs", mStats.mPolyStaticCVs);
addToString(statsStr, "PolyAnimCVs", mStats.mPolyAnimCVs);
addToString(statsStr, "PolyStaticFaces", mStats.mPolyStaticFaces);
addToString(statsStr, "PolyAnimFaces", mStats.mPolyAnimFaces);
addToString(statsStr, "CurveStaticNum", mStats.mCurveStaticNum);
addToString(statsStr, "CurveStaticCurves", mStats.mCurveStaticCurves);
addToString(statsStr, "CurveAnimNum", mStats.mCurveAnimNum);
addToString(statsStr, "CurveAnimCurves", mStats.mCurveAnimCurves);
addToString(statsStr, "CurveStaticCVs", mStats.mCurveStaticCVs);
addToString(statsStr, "CurveAnimCVs", mStats.mCurveAnimCVs);
addToString(statsStr, "PointStaticNum", mStats.mPointStaticNum);
addToString(statsStr, "PointAnimNum", mStats.mPointAnimNum);
addToString(statsStr, "PointStaticCVs", mStats.mPointStaticCVs);
addToString(statsStr, "PointAnimCVs", mStats.mPointAnimCVs);
addToString(statsStr, "NurbsStaticNum", mStats.mNurbsStaticNum);
addToString(statsStr, "NurbsAnimNum", mStats.mNurbsAnimNum);
addToString(statsStr, "NurbsStaticCVs", mStats.mNurbsStaticCVs);
addToString(statsStr, "NurbsAnimCVs", mStats.mNurbsAnimCVs);
addToString(statsStr, "TransStaticNum", mStats.mTransStaticNum);
addToString(statsStr, "TransAnimNum", mStats.mTransAnimNum);
addToString(statsStr, "LocatorStaticNum", mStats.mLocatorStaticNum);
addToString(statsStr, "LocatorAnimNum", mStats.mLocatorAnimNum);
addToString(statsStr, "CameraStaticNum", mStats.mCameraStaticNum);
addToString(statsStr, "CameraAnimNum", mStats.mCameraAnimNum);
if (statsStr.length() > 0)
{
Alembic::Abc::OStringProperty stats(mRoot.getTop().getProperties(),
"statistics");
stats.set(statsStr);
}
if (mTransTimeIndex != 0)
{
MString propName;
propName += static_cast<int>(mTransTimeIndex);
propName += ".samples";
Alembic::Abc::OUInt32Property samp(mRoot.getTop().getProperties(),
propName.asChar());
samp.set(mTransSamples);
}
if (mShapeTimeIndex != 0 && mShapeTimeIndex != mTransTimeIndex)
{
MString propName;
propName += static_cast<int>(mShapeTimeIndex);
propName += ".samples";
Alembic::Abc::OUInt32Property samp(mRoot.getTop().getProperties(),
propName.asChar());
samp.set(mShapeSamples);
}
MBoundingBox bbox;
if (mArgs.melPostCallback.find("#BOUNDS#") != std::string::npos ||
mArgs.pythonPostCallback.find("#BOUNDS#") != std::string::npos ||
mArgs.melPostCallback.find("#BOUNDSARRAY#") != std::string::npos ||
mArgs.pythonPostCallback.find("#BOUNDSARRAY#") != std::string::npos)
{
util::ShapeSet::const_iterator it = mArgs.dagPaths.begin();
const util::ShapeSet::const_iterator end = mArgs.dagPaths.end();
for (; it != end; it ++)
{
mCurDag = *it;
MMatrix eMInvMat;
if (mArgs.worldSpace)
{
eMInvMat.setToIdentity();
}
else
{
eMInvMat = mCurDag.exclusiveMatrixInverse();
}
bbox.expand(getBoundingBox(iFrame, eMInvMat));
}
}
processCallback(mArgs.melPostCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPostCallback, false, iFrame, bbox);
}
MBoundingBox AbcWriteJob::getBoundingBox(double iFrame, const MMatrix & eMInvMat)
{
MStatus status;
MBoundingBox curBBox;
if (iFrame == mFirstFrame)
{
// Set up bbox shape map in the first frame.
// If we have a lot of transforms and shapes, we don't need to
// iterate them for each frame.
MItDag dagIter;
for (dagIter.reset(mCurDag); !dagIter.isDone(); dagIter.next())
{
MObject object = dagIter.currentItem();
MDagPath path;
dagIter.getPath(path);
// short-circuit if the selection flag is on but this node is not in the
// active selection
// MGlobal::isSelected(ob) doesn't work, because DG node and DAG node is
// not the same even if they refer to the same MObject
if (mArgs.useSelectionList && !mSList.hasItem(path))
{
dagIter.prune();
continue;
}
MFnDagNode dagNode(path, &status);
if (status == MS::kSuccess)
{
// check for riCurves flag for flattening all curve object to
// one curve group
MPlug riCurvesPlug = dagNode.findPlug("riCurves", &status);
if ( status == MS::kSuccess && riCurvesPlug.asBool() == true)
{
MBoundingBox box = dagNode.boundingBox();
box.transformUsing(path.exclusiveMatrix()*eMInvMat);
curBBox.expand(box);
// Prune this curve group
dagIter.prune();
// Save children paths
std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter =
mBBoxShapeMap.insert(std::make_pair(mCurDag, util::ShapeSet())).first;
if (iter != mBBoxShapeMap.end())
(*iter).second.insert(path);
}
else if (object.hasFn(MFn::kParticle)
|| object.hasFn(MFn::kMesh)
|| object.hasFn(MFn::kNurbsCurve)
|| object.hasFn(MFn::kNurbsSurface) )
{
if (util::isIntermediate(object))
continue;
MBoundingBox box = dagNode.boundingBox();
box.transformUsing(path.exclusiveMatrix()*eMInvMat);
curBBox.expand(box);
// Save children paths
std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter =
mBBoxShapeMap.insert(std::make_pair(mCurDag, util::ShapeSet())).first;
if (iter != mBBoxShapeMap.end())
(*iter).second.insert(path);
}
}
}
}
else
{
// We have already find out all the shapes for the dag path.
std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter =
mBBoxShapeMap.find(mCurDag);
if (iter != mBBoxShapeMap.end())
{
// Iterate through the saved paths to calculate the box.
util::ShapeSet& paths = (*iter).second;
for (util::ShapeSet::iterator pathIter = paths.begin();
pathIter != paths.end(); pathIter++)
{
MFnDagNode dagNode(*pathIter, &status);
if (status == MS::kSuccess)
{
MBoundingBox box = dagNode.boundingBox();
box.transformUsing((*pathIter).exclusiveMatrix()*eMInvMat);
curBBox.expand(box);
}
}
}
}
return curBBox;
}
