void execute( const FutureMap& input,
                  PromiseMap& output ) const
    {
        RenderingSetGenerator renderSetGenerator( _cache );

        ConstCacheObjects cacheObjects;
        size_t nVisible = 0;
        size_t nAvailable = 0;
        size_t nNotAvailable = 0;
        for( const auto& visibles: input.get< NodeIds >( "VisibleNodes" ))
        {
            size_t available = 0;
            size_t notAvailable = 0;
            const ConstCacheObjects& objs = renderSetGenerator.generateRenderingSet( visibles,
                                                                                     available,
                                                                                     notAvailable );
            cacheObjects.insert( cacheObjects.end(), objs.begin(), objs.end( ));
            nVisible += visibles.size();
            nAvailable += available;
            nNotAvailable += notAvailable;
        }

        output.set( "CacheObjects", cacheObjects );
        output.set( "RenderingDone", cacheObjects.size() == nVisible );
        output.set( "AvailableCount", nAvailable );
        output.set( "NotAvailableCount", nNotAvailable );
    }
    ConstCacheObjects generateRenderingSet( const NodeIds& visibles,
                                            size_t& nAvailable,
                                            size_t& nNotAvailable ) const
    {
        ConstCacheMap cacheMap;
        for( const NodeId& nodeId : visibles )
        {
            collectLoadedTextures( nodeId, cacheMap );
            cacheMap.count( nodeId.getId( )) > 0 ? ++nAvailable : ++nNotAvailable;
        }

        if( visibles.size() != cacheMap.size( ))
        {
            ConstCacheMap::const_iterator it = cacheMap.begin();
            size_t previousSize = 0;
            do
            {
                previousSize = cacheMap.size();
                while( it != cacheMap.end( ))
                {
                    if( hasParentInMap( NodeId( it->first ), cacheMap ))
                        it = cacheMap.erase( it );
                    else
                        ++it;
                }
            }
            while( previousSize != cacheMap.size( ));
        }

        ConstCacheObjects cacheObjects;
        cacheObjects.reserve( cacheMap.size( ));
        for( ConstCacheMap::const_iterator it = cacheMap.begin();
             it != cacheMap.end(); ++it )
        {
            cacheObjects.push_back( it->second );
        }

        return cacheObjects;
    }
Пример #3
0
    void generateRenderBricks( const ConstCacheObjects& renderNodes,
                               RenderBricks& renderBricks )
    {
        renderBricks.reserve( renderNodes.size( ));
        BOOST_FOREACH( const ConstCacheObjectPtr& cacheObject, renderNodes )
        {
            const ConstTextureObjectPtr texture =
                boost::static_pointer_cast< const TextureObject >( cacheObject );

            RenderBrickPtr renderBrick( new RenderBrick( texture->getLODNode(),
                                                         texture->getTextureState( )));
            renderBricks.push_back( renderBrick );
        }
    }