CloudCreatorWang.h

#pragma once
#include "cloudgenerator.h"
#include <osg/BoundingBox>
#include <vector>
#include <iostream>
#include <string>

namespace osgCloudyDay
{
        class  TraverseMesh : public osg::NodeVisitor 
{
public:
     TraverseMesh() : NodeVisitor( NodeVisitor::TRAVERSE_ALL_CHILDREN ) 
         {
                 // ----------------------------------------------------------------------
                 //
                 //     Default Public Class Constructor
                 //
                 // ----------------------------------------------------------------------
         m_transformMatrix.makeIdentity();
    }

    virtual ~TraverseMesh() {}
        
    virtual void apply( osg::Geode &geode ) 
        {
                // -------------------------------------------
                //
                //   Handle nodes of the type osg::Geode
                //
                // -------------------------------------------        
       
        //
        // update bounding box for each drawable
        //
        for(  unsigned int i = 0; i < geode.getNumDrawables(); ++i )
                {           

            osg::BoundingBox bbox;
            bbox.expandBy( geode.getDrawable( i )->getBound());


                        //
                        // transform corners by current matrix
                        //
                        osg::BoundingBox bboxTrans;

                        std::cout << "center: " << bbox.center().x() << " " << bbox.center().y() << " " << bbox.center().z() << std::endl;
                        std::cout << "min: " << bbox.xMin() << " " << bbox.yMin() << " " << bbox.zMin() << std::endl;
                        std::cout << "max: " << bbox.xMax() << " " << bbox.yMax() << " " << bbox.zMax() << std::endl;
                        for( unsigned int i = 0; i < 8; ++i ) 
                        {      
                                osg::Vec3 xvec = bbox.corner( i ) * m_transformMatrix;
                                bboxTrans.expandBy( xvec );                             
                        }                       

                        std::cout << "bboxTrans: " << bboxTrans.center().x() << " " << bboxTrans.center().y() << " "  << bboxTrans.center().z() << std::endl;
                        m_boundingBox.push_back(bboxTrans);
        }        

        //
        // update the overall bounding box size
        //
        //m_boundingBox.expandBy( bboxTrans ); 

        //
        // continue traversing through the graph
        //
            traverse( geode );
       
    } // ::apply(osg::Geode &geode)
     
    virtual  void apply( osg::MatrixTransform &node ) 
        {
                // ---------------------------------------------------------
                //
                //   Handle nodes of the type osg::MatrixTransform
                //
                // ---------------------------------------------------------
        std::cout << "TRANSFORM NODE" << std::endl;
                m_transformMatrix *= node.getMatrix(); 
        
                //
        // continue traversing through the graph
        //
        traverse( node ); 

        } // ::apply(osg::MatrixTransform &node)

    virtual void apply( osg::Billboard &node )
        {
                // -----------------------------------------------
                //
                //    Handle nodes of the type osg::Billboard
                //
                // -----------------------------------------------

        //
        // important to handle billboard so that its size will
        // not affect the geode size continue traversing the graph
        //
        traverse( node );
    } // ::apply(osg::MatrixTransform &node)

    
        //
    // return teh bounding box     
    //
    std::vector<osg::BoundingBox> &getBoundBox() { return m_boundingBox; }  
        
protected :
    std::vector<osg::BoundingBox> m_boundingBox;          // the overall resultant bounding box
    osg::Matrix      m_transformMatrix;      // the current transform matrix 

};  // class  CcalculateBoundingBox
        
        class CloudCreatorWang :        public CloudGenerator
        {
        public:
                CloudCreatorWang(std::string path, osg::Vec3 middlepos, int type, osg::Vec4 color);
                ~CloudCreatorWang(void);

        protected:
                void Initialize();

                osg::Vec3 m_middlepos;

                int m_type;
                std::string m_path;
        };
}