Hi all,

I wonder if there is any osg function computing any node world space bounding 
box.

If not, i have done it but i think it can be optimized a bit..
Here i'm computing it for a drawable, i compute box vertices coordinates in 
world space then i do some min max on them.



Code:
osg::BoundingBox boundingBox = drawable->getBound ( );

osg::Vec3d p1 = osg::Vec3d ( boundingBox.xMin ( ), boundingBox.yMin ( ), 
boundingBox.zMin ( ) );
osg::Vec3d p2 = osg::Vec3d ( boundingBox.xMin ( ), boundingBox.yMin ( ), 
boundingBox.zMax ( ) );
osg::Vec3d p3 = osg::Vec3d ( boundingBox.xMin ( ), boundingBox.yMax ( ), 
boundingBox.zMin ( ) );
osg::Vec3d p4 = osg::Vec3d ( boundingBox.xMin ( ), boundingBox.yMax ( ), 
boundingBox.zMax ( ) );
osg::Vec3d p5 = osg::Vec3d ( boundingBox.xMax ( ), boundingBox.yMin ( ), 
boundingBox.zMin ( ) );
osg::Vec3d p6 = osg::Vec3d ( boundingBox.xMax ( ), boundingBox.yMin ( ), 
boundingBox.zMax ( ) );
osg::Vec3d p7 = osg::Vec3d ( boundingBox.xMax ( ), boundingBox.yMax ( ), 
boundingBox.zMin ( ) );
osg::Vec3d p8 = osg::Vec3d ( boundingBox.xMax ( ), boundingBox.yMax ( ), 
boundingBox.zMax ( ) );

osg::Vec3d p1w = p1 * matrix;
osg::Vec3d p2w = p2 * matrix;
osg::Vec3d p3w = p3 * matrix;
osg::Vec3d p4w = p4 * matrix;
osg::Vec3d p5w = p5 * matrix;
osg::Vec3d p6w = p6 * matrix;
osg::Vec3d p7w = p7 * matrix;
osg::Vec3d p8w = p8 * matrix;

double xMinw = std::min ( p1w.x ( ), std::min ( p2w.x ( ), std::min ( p3w.x ( 
), std::min ( p4w.x ( ), std::min ( p5w.x ( ), std::min ( p6w.x ( ), std::min ( 
p7w.x ( ), p8w.x ( ) ) ) ) ) ) ) );
double yMinw = std::min ( p1w.y ( ), std::min ( p2w.y ( ), std::min ( p3w.y ( 
), std::min ( p4w.y ( ), std::min ( p5w.y ( ), std::min ( p6w.y ( ), std::min ( 
p7w.y ( ), p8w.y ( ) ) ) ) ) ) ) );
double zMinw = std::min ( p1w.z ( ), std::min ( p2w.z ( ), std::min ( p3w.z ( 
), std::min ( p4w.z ( ), std::min ( p5w.z ( ), std::min ( p6w.z ( ), std::min ( 
p7w.z ( ), p8w.z ( ) ) ) ) ) ) ) );

double xMaxw = std::max ( p1w.x ( ), std::max ( p2w.x ( ), std::max ( p3w.x ( 
), std::max ( p4w.x ( ), std::max ( p5w.x ( ), std::max ( p6w.x ( ), std::max ( 
p7w.x ( ), p8w.x ( ) ) ) ) ) ) ) );
double yMaxw = std::max ( p1w.y ( ), std::max ( p2w.y ( ), std::max ( p3w.y ( 
), std::max ( p4w.y ( ), std::max ( p5w.y ( ), std::max ( p6w.y ( ), std::max ( 
p7w.y ( ), p8w.y ( ) ) ) ) ) ) ) );
double zMaxw = std::max ( p1w.z ( ), std::max ( p2w.z ( ), std::max ( p3w.z ( 
), std::max ( p4w.z ( ), std::max ( p5w.z ( ), std::max ( p6w.z ( ), std::max ( 
p7w.z ( ), p8w.z ( ) ) ) ) ) ) ) );

osg::Vec3d minWorld = osg::Vec3d(xMinw, yMinw, zMinw);
osg::Vec3d maxWorld = osg::Vec3d(xMaxw, yMaxw, zMaxw);



It looks like an horrible code ... but it works.
Does anyone know a most efficient way to compute it ?

Thank you for attention,
Regards,
Harold

------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=11972#11972





_______________________________________________
osg-users mailing list
osg-users@lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org

Reply via email to