render-configurator.cpp

Go to the documentation of this file.

/*
  RenderConfigurator  -  strategy to help building an actual render calculation stream
 
   Copyright (C)
     2011,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
* *****************************************************************/
 
 
#include "lib/error.hpp"
#include "steam/play/render-configurator.hpp"
#include "steam/play/output-manager.hpp"
#include "steam/engine/engine-service.hpp"
//#include "lib/itertools.hpp"
 
//#include <string>
//#include <memory>
#include <memory>
#include <functional>
 
 
 
namespace steam {
namespace play {
  
  namespace error = lumiera::error;
//    using std::string;
//    using lumiera::Subsys;
  using std::shared_ptr;
  using std::bind;
  using std::placeholders::_1;
  using engine::EngineService;
  
  typedef EngineService::QoS_Definition RenderQuality;
  
  
  namespace { // Implementation details...
    
//    using std::bind;
//    using std::function;
//    using std::placeholders::_1;
//    using lib::transform;
    
    class LumieraRenderProcessBuilder
      : public RenderConfigurator
      {
        
        POutputManager outputResolver_;
        Timings        playbackTimings_;
        RenderQuality  renderQuality_;
        
        
        OutputSlot&
        getOutputFor (ModelPort port)
          {
            REQUIRE (outputResolver_);
            OutputSlot& slot = outputResolver_->getOutputFor (port);
            if (!slot.isFree())
              throw error::State{"unable to acquire a suitable output slot"   
                                , LERR_(CANT_PLAY)};
            return slot;
          }
        
        
        engine::CalcStreams
        buildCalculationStreams (ModelPort port, OutputSlot& output)
          {
            OutputSlot::Allocation& activeOutputConnection = output.allocate();
            Timings nominalTimings = activeOutputConnection.getTimingConstraints()
                                                           .constrainedBy(playbackTimings_);
            
            return activateEngine (port, nominalTimings, activeOutputConnection, renderQuality_);
          }
        
        
        engine::CalcStreams
        activateEngine (ModelPort port, Timings timings, OutputSlot::Allocation& activeOutputConnection, RenderQuality quality)
          {
            return EngineService::instance().calculate (port, timings, activeOutputConnection, quality);
          }
        
        
      public:
        LumieraRenderProcessBuilder (POutputManager outputManager, Timings playbackSpeed)
          : outputResolver_(outputManager)
          , playbackTimings_(playbackSpeed)
          , renderQuality_(EngineService::QoS_DEFAULT)
          { }
        
      };
    
    
    
    inline RenderConfigurator*
    how_to_render (POutputManager outputPossibilities, Timings playTimings)
    {
      return new LumieraRenderProcessBuilder (outputPossibilities, playTimings);
    }
  
    
  } // (End) hidden service impl details
  
    
  
 
  RenderConfigurator::~RenderConfigurator() { } // emit VTable here...
  
  
  Feed
  RenderConfigurator::buildActiveFeed (ModelPort port)
  {
    OutputSlot& slot = getOutputFor (port);
    return Feed (buildCalculationStreams (port,slot));
  }
  
  
  
  
  RenderConfigurator::ConnectFunction
  buildRenderConfiguration (POutputManager outputPossibilities, Timings playTimings)
  {
    shared_ptr<RenderConfigurator> specialConfig{how_to_render (outputPossibilities,playTimings)};
    
    return [specialConfig](ModelPort port)
                          {
                            return specialConfig->buildActiveFeed(port);
                          };
  }
  
  
  
}} // namespace steam::play