connectivity-obsolete.hpp

Go to the documentation of this file.

/*
  PROC-NODE.hpp  -  Key abstraction of the Render Engine: a Processing Node

   Copyright (C)
     2008,            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_CONNECTIVITY_OBSOLETE_H
#define STEAM_ENGINE_CONNECTIVITY_OBSOLETE_H

#ifdef STEAM_ENGINE_PROC_NODE_H
  #error "can not include both the old and new Render Node Connectivity scheme"
#endif

#include "lib/error.hpp"
#include "steam/common.hpp"
#include "steam/asset/proc.hpp"
#include "steam/mobject/parameter.hpp"
#include "steam/engine/state-closure-obsolete.hpp"  
#include "steam/engine/channel-descriptor-obsolete.hpp"
#include "lib/frameid.hpp"
#include "lib/ref-array.hpp"

#include <vector>



namespace steam {
namespace engine {

  using std::vector;
  using lumiera::NodeID;
  
  class ProcNode_Obsolete;
  typedef ProcNode_Obsolete* PNode;
  
  
  class Connectivity
    {
    public: /* === public information record describing the node graph === */
      uint nrO;
      uint nrI;
      
      lib::RefArray<ChannelDescriptor>& out;
      lib::RefArray<InChanDescriptor>&  in;
      
      typedef asset::Proc::ProcFunc ProcFunc;
      
      ProcFunc* procFunction;
      
      NodeID const& nodeID;
      
      virtual ~Connectivity() {}
      
    protected:
      Connectivity (lib::RefArray<ChannelDescriptor>& o,
                        lib::RefArray<InChanDescriptor>& i,
                        ProcFunc pFunc, NodeID const& nID)
        : out(o), in(i),
          procFunction(pFunc),
          nodeID(nID)
        {
          nrO = out.size();
          nrI = in.size();
        }
      
      
      /* ==== strategy API for configuring the node operation ==== */
      
      friend class ProcNode_Obsolete;                               
      
      virtual BuffHandle
      callDown (StateClosure_OBSOLETE& currentProcess, uint requiredOutputNr)  const =0;
      
    };
  
  
  
  
  class ProcNode_Obsolete
    : util::NonCopyable
    {
      typedef mobject::Parameter<double> Param;   
      vector<Param> params;
      
      const Connectivity& wiringConfig_;
      
    public:
      ProcNode_Obsolete (Connectivity const& wd)
        : wiringConfig_(wd)
        { }
      
      virtual ~ProcNode_Obsolete() {};  
      
      
    public:
      bool isValid()  const;
      
      uint nrO() { return wiringConfig_.nrO; }
      
      
      BuffHandle
      pull (StateClosure_OBSOLETE& currentProcess, uint requestedOutputNr=0)  const
        {
          return this->wiringConfig_.callDown (currentProcess, requestedOutputNr);
        }
      
    };
  
  
  inline bool
  ProcNode_Obsolete::isValid()  const
  {
    UNIMPLEMENTED ("ProcNode validity self-check");
    return false; 
  }
  
  
}} // namespace steam::engine
#endif /*STEAM_ENGINE_CONNECTIVITY_OBSOLETE_H*/