src/fogcube.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by                                                 *
 *         Pierre-yves JEZEQUEL, Julien MICHOT, Loic MOISAN,               *
 *         Julien PAPILLON, Sebastien PINEAUD, Barthelemy SERRES           *
 *                                                                         *
 *   https://sourceforge.net/projects/anidam                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "fogcube.h"



FogCube::FogCube()
 : osg::Fog()
{
}


FogCube::~FogCube()
{
}

void FogCube::setCube(float xmin,float xmax,float ymin,float ymax,float zmin,float zmax)
{
        this->xmin = xmin;
        this->xmax = xmax;
        this->ymin = ymin;
        this->ymax = ymax;
        this->zmin = zmin;
        this->zmax = zmax;
        
        node=NULL;
}

bool FogCube::isInTheCube( float x,float y,float z)
{
        return ( x>=xmin && x<=xmax && y>=ymin && y<=ymax && z>=zmin && z<=zmax)  ;
}
void FogCube::addStaticFogCoords(osg::Node* node)
{
        //static 
        setFogCoordinateSource(osg::Fog::FOG_COORDINATE);
        
        this->node=node;
        addFog(node);
        
        osg::Geode* tempGeode = dynamic_cast<osg::Geode*>(node);
        if(tempGeode!= NULL)
        {
                std::cout<<"drawables : " << tempGeode->getNumDrawables() <<std::endl;
                int i;
                for (i = 0; i < tempGeode->getNumDrawables(); i ++)
                {
                        osg::Geometry* tempGeometry =dynamic_cast<osg::Geometry*>(tempGeode->getDrawable(i));
                        if (tempGeometry != NULL)
                        {
                                osg::Vec3Array* vertices =dynamic_cast<osg::Vec3Array*>(tempGeometry->getVertexArray());
                                int numVertices = vertices->getNumElements();
                                osg::FloatArray* coords = new osg::FloatArray(numVertices);
                                for (int i=0; i < numVertices; i ++)
                                {
                                        float offset = (zmax - (*vertices)[i].z());
                                        (*coords)[i] = 0.0;
                                        if(isInTheCube((*vertices)[i].x(),(*vertices)[i].y(),(*vertices)[i].z())) 
                                                (*coords)[i] = offset;
                                }

                                tempGeometry->setFogCoordArray(coords);
                                tempGeometry->setFogCoordBinding(osg::Geometry::BIND_PER_VERTEX);
                        }
                }
                return;
        }

        osg::Group* tempGroup = dynamic_cast<osg::Group*>(node);
        if(tempGroup!= NULL)
        {
                int i;
                for (i = 0; i < tempGroup->getNumChildren(); i ++)
                {
                        addStaticFogCoords(tempGroup->getChild(i));
                }
                return;
        }

        int temp = 1;
}

void FogCube::addDynamicFogCoords(osg::Node* node)
{
        this->node=node;
        addFog(node);
        
        osg::Geode* tempGeode = dynamic_cast<osg::Geode*>(node);
        if(tempGeode!= NULL)
        {
                //std::cout<<"drawables : " << tempGeode->getNumDrawables() <<std::endl;
                int i;
                for (i = 0; i < tempGeode->getNumDrawables(); i ++)
                {
                        osg::Geometry* tempGeometry =dynamic_cast<osg::Geometry*>(tempGeode->getDrawable(i));
                        if (tempGeometry != NULL)
                        {
                                osg::Vec3Array* vertices =dynamic_cast<osg::Vec3Array*>(tempGeometry->getVertexArray());
                                int numVertices = vertices->getNumElements();
                                osg::FloatArray* coords = new osg::FloatArray(numVertices);
                                for (int i=0; i < numVertices; i ++)
                                {
                                        float offset = (zmax - (*vertices)[i].z());
                                        (*coords)[i] = 0.0;
                                        if(isInTheCube((*vertices)[i].x(),(*vertices)[i].y(),(*vertices)[i].z())) 
                                                (*coords)[i] = offset;
                                        //std::cout<<"coord : " << offset <<std::endl;
                                }

                                tempGeometry->setFogCoordArray(coords);
                                tempGeometry->setFogCoordBinding(osg::Geometry::BIND_PER_VERTEX);
                        }
                }
                return;
        }

        osg::Group* tempGroup = dynamic_cast<osg::Group*>(node);
        if(tempGroup!= NULL)
        {
                std::cout<<"gr : " << tempGroup->getNumChildren() <<std::endl;
                int i;
                for (i = 0; i < tempGroup->getNumChildren(); i ++)
                {
                        addDynamicFogCoords(tempGroup->getChild(i));
                }
                return;
        }

        int temp = 1;
}
bool FogCube::addFog(osg::Node* node)
{
        this->node=node;

        osg::StateSet* stateset = node->getOrCreateStateSet();
        stateset->setAttribute(this, osg::StateAttribute::ON);
        stateset->setMode(GL_FOG, osg::StateAttribute::ON);

        return true;
}

osg::Node*  FogCube::createMultiplesDrawables()
{
        if(node==NULL)
                return node;
        
        osg::Geode* geode = new osg::Geode();
        
        // ---------------------------------------
        // Recover the stateset of the main element
        // ---------------------------------------
        osg::StateSet* stateset = node->getOrCreateStateSet();
        geode->setStateSet( stateset );
        
        osg::Geode* tempGeode = dynamic_cast<osg::Geode*>(node);
        
        if(tempGeode!= NULL)
        {
                std::cout<< "nb drawables : " << tempGeode->getNumDrawables() << std::endl;
                
                osg::Drawable * drw = tempGeode->getDrawable(0);
                osg::Geometry * geom = drw->asGeometry();
                
                std::cout<< "nb geom :  " << geom->getNumPrimitiveSets() << std::endl;
                std::cout<< "PS 1  :  " << geom->getPrimitiveSet(0)->className()<< geom->getPrimitiveSet(0)->getNumPrimitives() << std::endl;
                
                for(unsigned int i=0;i<geom->getPrimitiveSet(0)->getNumPrimitives();i++)
                {
                                
                }
                
                /*
                osg::Geometry* geometry = new osg::Geometry;

                osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows));
                osg::Vec2Array& t = *(new osg::Vec2Array(numColumns*numRows));
        //osg::UByte4Array& color = *(new osg::UByte4Array(1));   
         
                osg::Vec4Array* color = new osg::Vec4Array(1);
                (*color)[0].set(1.0f,1.0f,1.0f,1.0f);
        

                float rowCoordDelta = size.y()/(float)(numRows-1);
                float columnCoordDelta = size.x()/(float)(numColumns-1);

                float rowTexDelta = 1.0f/(float)(numRows-1);
                float columnTexDelta = 1.0f/(float)(numColumns-1);

                osg::Vec3 pos = origin;
                osg::Vec2 tex(0.0f,0.0f);
                int vi=0;
                for(r=0;r<numRows;++r)
                {
                        pos.x() = origin.x();
                        tex.x() = 0.0f;
                        for(c=0;c<numColumns;++c)
                        {

                                v[vi].set(pos.x(),pos.y(),pos.z()+(vertex[r+c*numRows][2]-min_z)*scale_z);
                                t[vi].set(tex.x(),tex.y());
                                pos.x()+=columnCoordDelta;
                                tex.x()+=columnTexDelta;
                                ++vi;
                        }
                        pos.y() += rowCoordDelta;
                        tex.y() += rowTexDelta;
                }

                geometry->setVertexArray(&v);
                geometry->setColorArray(color);
                geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
                geometry->setTexCoordArray(0,&t);

                for(r=0;r<numRows-1;++r)
                {
                        osg::DrawElementsUShort& drawElements = *(new
                                        osg::DrawElementsUShort(GL_QUAD_STRIP,2*numColumns));
                        geometry->addPrimitiveSet(&drawElements);
                        int ei=0;
                        for(c=0;c<numColumns;++c)
                        {
                                drawElements[ei++] = (r+1)*numColumns+c;
                                drawElements[ei++] = (r)*numColumns+c;
                        }
                }

                geode->addDrawable(geometry);

                osgUtil::SmoothingVisitor sv;
                sv.smooth(*geometry);
                
                */
                
        }

        //node=geode;
        return node;//geode;
}

---