DtHdrDrawableRenderData.h

Go to the documentation of this file.

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


#pragma once

#include <vrvPostProcessor/vrvPostProcessor.h>
#include <vrvPostProcessor/DtHdrTypes.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Drawable>
#include <osg/Texture>
#include <osg/Texture2D>

#include <array>

namespace osg
{
   class RenderInfo;
   class Camera;
   class State;
}

namespace makVrv
{
   class DtDe;

   class DtGlTexture;
   class DtGlBuffer;
   class DtGlProgram;

   class DtHdrDrawable;
   struct DtHdrOptions;

   class DtHdrDrawableRenderData;

   typedef DtVirtualBaseClassCreator<DtHdrDrawableRenderData, const DtHdrOptions&, DtHdrDrawable*, osg::Texture*&> DtHdrDrawableRenderDataCreator;

   template <>
   inline const char* creatorTypeName<DtHdrDrawableRenderData>(void) { return "DtHdrDrawableRenderDataCreator"; }

   class DT_DLL_VRVPOSTPROCESSOR DtHdrDrawableRenderData
   {
   public:
      friend DtHdrDrawableRenderDataCreator;

      virtual ~DtHdrDrawableRenderData();

      DtHdrDrawableRenderData() = delete;
      DtHdrDrawableRenderData(const DtHdrDrawableRenderData& rhs) = delete;
      DtHdrDrawableRenderData& operator=(const DtHdrDrawableRenderData& rhs) = delete;

   public:
      virtual void initShaders();

      virtual void execute(osg::RenderInfo& renderInfo);

      virtual void cleanupGpuMemory();

      virtual void setInputTexture(osg::Texture* inputTex);

      virtual float localHdrOutputScale();

   protected:
      DtHdrDrawableRenderData(DtDe& de, const DtHdrOptions& options, DtHdrDrawable* parent, osg::Texture*& lensFlareTexture);
   protected:
      virtual void initRenderTextures(const osg::Camera* osgCamera);

      virtual void downSample(DtGlTexture* src, DtGlTexture* dest, osg::State* state);

      virtual void downsample4x(DtGlTexture* src, DtGlTexture* dest, osg::State* state);

      virtual void extractHL(DtGlTexture* src, DtGlTexture* dest, osg::State* state);

      virtual void runPass(HDR_PASS prog, DtGlTexture* src, DtGlTexture* dest,
         osg::State* state);

      virtual void blur(DtGlTexture* src, DtGlTexture* dest, DtGlTexture* temp,
         int blurWidth, osg::State* state);

      virtual void getBufferPyramidSize(BUFFER_PYRAMID level, int* w, int* h);

      virtual void genStarStreak(int streak, float dir, float length);

      virtual void genGhostImage(const float* ghost_modulation1st, const float* ghost_modulation2nd, osg::State* state);

      virtual void composeEffect(void);

      virtual void toneMappingPass(osg::State* state);

      virtual void calculateLuminance(const osg::Camera* osgCamera);

      virtual float adaptiveLuminance(const osg::Camera* osgCamera);

      virtual bool adaptiveLuminanceCompute(const osg::Camera* osgCamera);

      virtual float adaptiveLuminanceRead(const osg::Camera* osgCamera);

      virtual float regularLuminance(const osg::Camera* osgCamera);

      virtual float silverLiningLuminance(const osg::Camera* osgCamera);

      virtual void computeColorModulationRedShift(float* color, float r, float g, float b, int num);
      virtual void computeColorModulation(float* color, float r, float g, float b, int num);
      virtual void computeColorModulationCoefficients();

      virtual void createComputeProgramIfNecessary(HDR_PASS pass, const std::string& name);
      virtual void createBlurProgramsIfNecessary();

      virtual std::string preprocessorDefinesString(HDR_PASS pass);

      virtual unsigned int inputTextureId(unsigned int& target, const DtGlTexture* src, osg::State* state);

      virtual void streakPass0(int streak, float dec, const float step[2], float stride);
      virtual void streakPass1(int streak, float dec, const float step[2], float stride);
      virtual void streakPass2(int streak, float dec, const float step[2], float stride);

      virtual void ghostPass0(const float* ghost_modulation1st);
      virtual void ghostPass1(const float* ghost_modulation2nd);

      virtual void gaussianBlurComposePass(void);
      virtual void starStreakCompose(void);
      virtual void finalGlarePass(void);

      virtual void initializeUniformLocations(HDR_PASS pass);
      virtual void zeroOutUniformLocations();

      virtual void createToneMappingProgramIfNecessary(void);

      virtual void slot_hdrResolutionScaleChanged(int val);
   protected:
      DtDe& myDe;

      const DtHdrOptions& myOptions;

      float myAspectRatio;

      std::array<DtGlProgram*, PROGSIZE> myShaders;

      float myStarModulation1st[16];
      float myStarModulation2nd[16];
      float myStarModulation3rd[16];

      float myFilmicGhostModulation1st[16];
      float myFilmicGhostModulation2nd[16];
      float myCameraGhostModulation1st[16];
      float myCameraGhostModulation2nd[16];

      float myHoriModulation1st[16];
      float myHoriModulation2nd[16];
      float myHoriModulation3rd[16];


      DtGlTexture* myComposebuffer[LEVEL_TOTAL];
      DtGlTexture* myBlurbufferA[LEVEL_TOTAL];
      DtGlTexture* myBlurbufferB[LEVEL_TOTAL];

      DtGlTexture* myStreakbufferA[8];
      DtGlTexture* myStreakbufferB[8];
      DtGlTexture* myStreakbufferFinal;

      DtGlTexture* myGhost1stBuffer;
      DtGlTexture* myGhost2ndBuffer;

      DtGlTexture* myGlareBuffer;

      DtGlTexture* myLumcurrent;

      unsigned int myLumNextBuffer;
      const float* myLumNextBufferPtr;

      DtGlTexture* myInitialBuffer;

      double myLastAdpativeLumFrameTime;

      int myExtractHlTresholdAndScalarLoc;

      int myStarStreakStepSizeAndStrideLoc;
      int myStarStreakColorCoeffLoc;

      int myGhostImageScalarLoc;
      int myGhostImageColorCoeffLoc;

      int myGaussianBlurComposeCoeffLoc;
      int myStarStreakComposeNumSamplersLoc;
      int myFinalGlarecomposeMixCoeffLoc;

      int myElapsedTimeLoc;

      int mySceneTexLoc;
      int myBlurTexLoc;

      int myScalesBlurTexLuminanceSaturationLoc;
      int myBlurAmountGammaEnablePassThroughLoc;

      float myLastLuminanceValue;

      double myLastHdrFrameTime = -1;

      DtHdrDrawable* myParent = nullptr;

      // Signals and slots
      DtSignalConnectionManager myConnections;

      osg::ref_ptr<osg::Texture> myLensMask;
      osg::ref_ptr<osg::Texture> myInputTex;
   };
}