bool RenderAction::pushVisibility(void)
{
    if(_pActivePartition->pushVisibility(getActNode()) == false)
    {
        useNodeList(); // ignore all children
        return false;
    }

    return true;
}
void ShadingAction::dropFunctor(Material::DrawFunctor &func, 
                                ShadingMaterial       *mat )
{
#if 0
    Material *pMat;
    State    *pState;

    if(_pMaterial != NULL)
    {
        pMat = _pMaterial;
    }
    else if(mat != NULL)
    {
        pMat = mat;
    }
    else
    {
        return;
    }

    MaterialMap::iterator it        = _mMatMap.find(pMat);

#if 0
    pMat->rebuildState();
#endif

    pState = pMat->getState().getCPtr();

    if(_bSortTrans == true && pMat->isTransparent() == true)
    {
#if defined(OSG_OPT_DRAWTREE)
        DrawTreeNode *pNewElem = _pNodeFactory->create();
#else
        DrawTreeNode *pNewElem = new DrawTreeNode;
#endif

        Pnt3f         objPos;
            
        getActNode()->getVolume().getCenter(objPos);
        
        _currMatrix.second.mult(objPos);
            
        pNewElem->setNode       (getActNode());
            
        pNewElem->setFunctor    (func);
        pNewElem->setMatrixStore(_currMatrix);
            
        pNewElem->setState      (pState);
        pNewElem->setScalar     (objPos[2]);

        if(_pTransMatRoot->getFirstChild() == NULL)
        {
            _pTransMatRoot->addChild(pNewElem);
        }
        else
        {
            DrawTreeNode *pCurrent = _pTransMatRoot->getFirstChild();
            DrawTreeNode *pLast    = NULL;
            bool          bFound   = false;

            do
            {

                if(pNewElem->getScalar() > pCurrent->getScalar())
                {
                    pLast    = pCurrent;
                    pCurrent = pCurrent->getBrother();
                }
                else
                {
                    bFound = true;
                }

            } while(bFound   == false && 
                    pCurrent != NULL    );
            
            
            if(bFound == true)
            {
                if(pLast == NULL)
                {
                    _pTransMatRoot->insertFirstChild(       pNewElem);
                }
                else
                {
                    _pTransMatRoot->insertChildAfter(pLast, pNewElem);
                }
            }
            else
            {
                _pTransMatRoot->addChild(pNewElem);
            }
        }


        _uiNumTransGeometries++;
    }
    else
    {
#if defined(OSG_OPT_DRAWTREE)
        DrawTreeNode *pNewElem = _pNodeFactory->create();
#else
        DrawTreeNode *pNewElem = new DrawTreeNode;
#endif 
       
        if(it == _mMatMap.end())
        {
#if defined(OSG_OPT_DRAWTREE)
            DrawTreeNode *pNewMatElem = _pNodeFactory->create();
#else
            DrawTreeNode *pNewMatElem = new DrawTreeNode;
#endif            
            _mMatMap[pMat].push_back(pNewMatElem);
            
            pNewElem->setNode       (getActNode());
            
            pNewElem->setFunctor    (func);
            pNewElem->setMatrixStore(_currMatrix);
            
            pNewMatElem->addChild(pNewElem);
            pNewMatElem->setState(pState);
            
            _pMatRoot->addChild(pNewMatElem);
        }
        else
        {
            std::vector<DrawTreeNode *>::iterator treesIt = it->second.begin();
            std::vector<DrawTreeNode *>::iterator treesEnd= it->second.end();

            pNewElem->setFunctor    (func);
            pNewElem->setMatrixStore(_currMatrix);
            
            for(;treesIt != treesEnd; ++treesIt)
            {
                (*treesIt)->addChild(pNewElem);
            }
        }
    }
#endif
}