DtPostProcessor.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2020 MAK Technologies, Inc.
* All rights reserved.
*****************************************************************************/

#pragma once


#include <vrvPostProcessor/vrvPostProcessor.h>

#include <osg/Camera>
#include <osg/Texture>
#include <osg/Program>
#include <osg/Shader>
#include <osg/Texture2D>
#include <osg/Geode>

#include <map>

#include <boost/unordered_map.hpp>

namespace makVrv 
{ 
   class DtChannel;

   // When attaching / detaching buffers from the camera
   // You need to call setCameraRequiresSetUp since there is (and will be) 
   // a bug in OSG's camera caching behavior
   class DtPostProcessorCullVistorCallback : public osg::NodeCallback
   {
   public:

      DtPostProcessorCullVistorCallback() : osg::NodeCallback(), myDirty(true)
      {
      }

      // Callback method called by the NodeVisitor when visiting a node.
      virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);

      virtual void setDirty(bool flag);

   protected:

      bool myDirty;
   };


   class DT_DLL_VRVPOSTPROCESSOR DtPostProcessor
   {
   public:
      friend class DtPostProcessManager;

      DtPostProcessor(const std::string& postProcessType, bool handles2D);

      virtual ~DtPostProcessor();

      virtual void setFragmentShaderSource(const char *source);

      virtual void setVertexShaderSource(const char *source);

      virtual void setFragmentShaderFile(const std::string& fileName);

      virtual void setVertexShaderFile(const std::string& fileName);


      virtual void setInputTexture(const DtChannel *channel, osg::Texture* texture);

      virtual bool update(DtChannel *channel) = 0;

      virtual osg::Texture* outputTexture();

      virtual void setIsFinalEffect(const DtChannel *channel, bool final);

      virtual osg::Camera* cameraForChannel(const DtChannel *channel);

      virtual void releaseGLObjects();

      virtual bool hasEffect(const std::string& effect);

      virtual bool effectEnabled(const std::string& effect);

      virtual bool anyEffectEnabled();

      virtual bool enableEffect(const std::string& effect);
      virtual bool disableEffect(const std::string& effect);

      virtual std::list<std::string> supportedEffects();

      virtual bool handles2D() const;

      virtual const std::string& type() const;

      virtual void enablePostProcessor();
      virtual void disablePostProcessor();

      virtual bool postProcessorEnabled() const;

   protected:

      // A list of sub-effects that can be enabled/disabled
      typedef boost::unordered_map<std::string, bool> EffectMap;

      virtual bool effectItrEnabled(EffectMap::iterator &effect);

      virtual void initialize();

      virtual void addEffect(std::string effect);

      virtual void setEnablePostProcessor(bool enabled);

   protected:

      osg::ref_ptr<osg::Texture> myOutputTexture, myInputTexture;
      osg::ref_ptr<osg::Program> myProgram;
      osg::ref_ptr<osg::Shader> myFragmentShader;
      osg::ref_ptr<osg::Shader> myVertexShader;
      osg::ref_ptr<osg::Geode> myQuad;

      typedef std::map<const DtChannel*, osg::ref_ptr<osg::Camera> > CameraMap;
      CameraMap myCameraMap;

      bool myHandles2DFlag;
      bool myEnabledFlag;

      // The category of this post effect ex. "dof", "wateronscreen"
      std::string myType;

      
      EffectMap myEffects; // ex. { {"rainsplash",true}, {"oceanspray",false} }

      //Needed in order to mark the correct callbacks dirty to avoid 
      // extra calls to set camera requres setup.
      typedef osg::ref_ptr<DtPostProcessorCullVistorCallback> CallbackRefPtr;
      typedef std::map< const DtChannel*, CallbackRefPtr > CallbackMap;

      CallbackMap myCullCallbackMap;
   };

   class DT_DLL_VRVPOSTPROCESSOR DtPostProcessorCreator
   {
   public:
      friend class DtPostProcessorFactory;

      DtPostProcessorCreator();

      virtual ~DtPostProcessorCreator();

   protected:
      virtual DtPostProcessor* create(DtDe& de, const std::string& postProcessorType) = 0;
   };
}