FrameRendererHelper.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 - 2015 Leonid Kostrykin
 *
 *  Chair of Medical Engineering (mediTEC)
 *  RWTH Aachen University
 *  Pauwelsstr. 20
 *  52074 Aachen
 *  Germany
 *
 */

#ifndef FRAMERENDERERHELPER_H_6014714286
#define FRAMERENDERERHELPER_H_6014714286

#include <Carna/Carna.h>
#include <Carna/base/Log.h>
#include <Carna/base/text.h>
#include <Carna/base/RenderStageSequence.h>
#include <Carna/base/RenderStage.h>
#include <Carna/base/GLContext.h>
#include <Carna/base/MeshRenderingStage.h>
#include <Carna/presets/MeshColorCodingStage.h>
#include <Carna/presets/OccludedRenderingStage.h>
#include <set>

namespace Carna
{

namespace helpers
{



// ----------------------------------------------------------------------------------
// DefaultRenderStageOrder
// ----------------------------------------------------------------------------------

class CARNA_LIB DefaultRenderStageOrder : std::binary_function< base::RenderStage*, base::RenderStage*, bool >
{

public:

    bool operator()( const base::RenderStage* x, const base::RenderStage* y ) const;

}; // DefaultRenderStageOrder



// ----------------------------------------------------------------------------------
// FrameRendererHelper
// ----------------------------------------------------------------------------------

template< typename RenderStageOrder >
class FrameRendererHelper
{

    NON_COPYABLE

    std::set< base::RenderStage*, RenderStageOrder > stages;

public:

    explicit FrameRendererHelper( base::RenderStageSequence& renderer );

    ~FrameRendererHelper();
    
    FrameRendererHelper< RenderStageOrder >& operator<<( base::RenderStage* rs );

    base::RenderStageSequence& renderer;

    void reset();

    void commit( bool clear = true );

}; // FrameRendererHelper


template< typename RenderStageOrder >
FrameRendererHelper< RenderStageOrder >::FrameRendererHelper( base::RenderStageSequence& renderer )
    : renderer( renderer )
{
}


template< typename RenderStageOrder >
FrameRendererHelper< RenderStageOrder >::~FrameRendererHelper()
{
    reset();
}


template< typename RenderStageOrder >
void FrameRendererHelper< RenderStageOrder >::reset()
{
    std::for_each( stages.begin(), stages.end(), std::default_delete< base::RenderStage >() );
    stages.clear();
}


template< typename RenderStageOrder >
void FrameRendererHelper< RenderStageOrder >::commit( bool clear )
{
    if( clear )
    {
        renderer.clearStages();
    }
    presets::MeshColorCodingStage* mccs = nullptr;
    presets::OccludedRenderingStage* occluded = nullptr;
    unsigned int registeredMeshColorCodingStages = 0;
    unsigned int enabledOccludedStages = 0;
    for( auto stageItr = stages.begin(); stageItr != stages.end(); ++stageItr )
    {
        base::RenderStage* const rs = *stageItr;
        renderer.appendStage( rs );

        if( mccs == nullptr )
        {
            mccs = dynamic_cast< presets::MeshColorCodingStage* >( rs );
        }
        if( occluded == nullptr )
        {
            occluded = dynamic_cast< presets::OccludedRenderingStage* >( rs );
        }

        base::MeshRenderingStageBase* const meshRenderer = dynamic_cast< base::MeshRenderingStageBase* >( rs );
        if( meshRenderer != nullptr && mccs != nullptr )
        {
            mccs->putGeometryType( meshRenderer->geometryType, meshRenderer->ROLE_DEFAULT_MESH );
            mccs->enableMaterials( meshRenderer->geometryType, meshRenderer->ROLE_DEFAULT_MATERIAL );
            ++registeredMeshColorCodingStages;
        }
        if( meshRenderer != nullptr && occluded != nullptr )
        {
            occluded->enableStage( *rs );
            ++enabledOccludedStages;
        }
    }
    base::Log::instance().record( base::Log::debug
        , "FrameRendererHelper registered "
        + base::text::lexical_cast< std::string >( registeredMeshColorCodingStages )
        + " stage(s) for color coding." );
    base::Log::instance().record( base::Log::debug
        , "FrameRendererHelper enabled "
        + base::text::lexical_cast< std::string >( enabledOccludedStages )
        + " stage(s) for occluded rendering." );
    stages.clear();
}


template< typename RenderStageOrder >
Carna::helpers::FrameRendererHelper< RenderStageOrder >& FrameRendererHelper< RenderStageOrder >::operator<<( Carna::base::RenderStage* rs )
{
    stages.insert( rs );
    return *this;
}



}  // namespace Carna :: helpers

}  // namespace Carna



#endif // FRAMERENDERERHELPER_H_6014714286