procnode.hpp

Go to the documentation of this file.

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

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef ENGINE_PROCNODE_H
#define ENGINE_PROCNODE_H

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

#include <vector>



namespace steam {
namespace engine {

  using std::vector;
  using proc_interface::State;
  using lumiera::NodeID;
  
  class ProcNode;
  typedef ProcNode* PNode;
  
  
  class WiringDescriptor
    {
    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 ~WiringDescriptor() {}
      
    protected:
      WiringDescriptor (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;                               
      
      virtual BuffHandle
      callDown (State& currentProcess, uint requiredOutputNr)  const =0; 
      
    };
  
  
  
  
  class ProcNode
    : util::NonCopyable
    {
      typedef mobject::Parameter<double> Param;   
      vector<Param> params;
      
      const WiringDescriptor& wiringConfig_;
      
    public:
      ProcNode (WiringDescriptor const& wd)
        : wiringConfig_(wd)
        { }
      
      virtual ~ProcNode() {};  
      
      
    public:
      bool isValid()  const;
      
      uint nrO() { return wiringConfig_.nrO; }
      
      
      BuffHandle
      pull (State& currentProcess, uint requestedOutputNr=0)  const
        {
          return this->wiringConfig_.callDown (currentProcess, requestedOutputNr);
        }
      
    };
  
  
  inline bool
  ProcNode::isValid()  const
  {
    UNIMPLEMENTED ("ProcNode validity self-check");
    return false; 
  }
  
  
}} // namespace steam::engine
#endif