engine-service.hpp

Go to the documentation of this file.

/*
  ENGINE-SERVICE.hpp  -  primary service access point for using the renderengine
 
   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.
 
*/
 
#ifndef STEAM_ENGINE_ENGINE_SERVICE_H
#define STEAM_ENGINE_ENGINE_SERVICE_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
//#include "include/dummy-player-facade.h"
//#include "include/display-facade.h"
#include "steam/engine/calc-stream.hpp"
#include "steam/mobject/model-port.hpp"
#include "steam/play/timings.hpp"
#include "steam/play/output-slot.hpp"
//#include "common/instancehandle.hpp"
//#include "lib/singleton-ref.hpp"
#include "lib/polymorphic-value.hpp"
#include "lib/depend.hpp"
 
#include <functional>
//#include <string>
 
 
namespace steam {
namespace engine{
 
//    using std::string;
//    using lumiera::Subsys;
//    using lumiera::Display;
//    using lumiera::DummyPlayer;
//  using std::function;
  using mobject::ModelPort;
  using steam::play::Timings;
  
  using OutputConnection = steam::play::OutputSlot::Allocation;
  
  
  
  
  
  /**************************************************/
  class EngineService
    : util::NonCopyable
    {
      
      
      /* The following typedefs allow to hand out predefined
       * Quality-of-Service strategy definitions as value objects,
       * without disclosing implementation details here in this header.
       */
      enum{ QoS_IMPL_SIZE = sizeof(size_t) };  
      
      
    public:
      /*********************************************************/
      class Quality
        {
          public:
            virtual ~Quality() { };  
        };
      
      
      using _Clonable_QoS_Strategy = lib::polyvalue::CloneValueSupport<Quality>;
      using  QoS_Definition        = lib::PolymorphicValue<Quality, QoS_IMPL_SIZE, _Clonable_QoS_Strategy>;
      
      static QoS_Definition  QoS_DEFAULT;
      static QoS_Definition  QoS_BACKGROUND;
      static QoS_Definition  QoS_SYNC_PRIORITY;
      static QoS_Definition  QoS_PERFECT_RESULT;
      static QoS_Definition  QoS_COMPROMISE;
      
      
      static lib::Depend<EngineService> instance;
      
      
      virtual ~EngineService() { }
      
      EngineService();
      
      CalcStreams
      calculate(ModelPort mPort,
                Timings nominalTimings,
                OutputConnection& output,
                Quality serviceQuality =QoS_DEFAULT);
      
      CalcStreams
      calculateBackground(ModelPort mPort,
                          Timings nominalTimings,
                          Quality serviceQuality =QoS_BACKGROUND);
      
      
    protected:
      virtual RenderEnvironment& configureCalculation (ModelPort,Timings,Quality);
      
      void activateTracing();
      void disableTracing(); 
      
      friend class EngineDiagnostics;
      
    private:
      static CalcStream activateCalculation (play::DataSink, RenderEnvironment&);
    };
  
  
  
  
  
  
}} // namespace steam::engine
#endif /*STEAM_ENGINE_ENGINE_SERVICE_H*/