DtImguiDrawable.h

Go to the documentation of this file.

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


#pragma once 

#include <vrvOsg/vrvOsg.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtEventProcessorInterface.h>

#include <vrvUtil/signalslib.h>

#include <osg/Drawable>
#include <osg/BlendEquation>
#include <osg/BlendFunc>
#include <osg/ref_ptr>

struct ImDrawData;

namespace makVrv
{
   class DtDe;
   class DtOsgRenderer;
   class DtMouseEvent;
   class DtMouseEvent;
   class DtImguiDrawable;

   class DT_DLL_VRVOSG DtImguiTweakUI
   {
   public:
      virtual void createImGui() = 0;
   };

   class DT_DLL_VRVOSG DtImGuiEventProcessor : public DtEventProcessorInterface
   {
   public:
      DtImGuiEventProcessor(DtDe& de, DtImguiDrawable& imGuiDrawable);

      virtual ~DtImGuiEventProcessor();

      virtual bool processMouseEvent(const DtMouseEvent& ev, DtChannel& channel);
      virtual bool processKeyboardEvent(const DtKeyEvent& ev, DtChannel& channel);

      virtual const std::string& className();
      virtual void setKeyboardActive(bool enable) { myIsKeyboardActive = enable; }

   protected:

      virtual void convertMouseCoordinatesForVr(DtChannel& channel, int& mouseX, int& mouseY);

   protected:
      DtDe& myDe;
      std::string myClassName;
      bool myIsKeyboardActive;
      bool myRightMouseMoveActive;
      DtImguiDrawable& myImGuiDrawable;
   };

   class DtGlContextWrapper;
   class NetworkMonitorGui;
   class DT_DLL_VRVOSG DtImguiDrawable : public osg::Drawable
   {
   public:

      DtImguiDrawable(DtDe& de);

      virtual ~DtImguiDrawable();

      virtual void drawImplementation(osg::RenderInfo& info) const;
      virtual void releaseGLObjects(osg::State* state/* =0 */) const;

      virtual void shutdown();

      virtual void addUI(DtImguiTweakUI* ui);
      virtual void removeUI(DtImguiTweakUI* ui);

      virtual bool readyToRender();

      virtual osg::observer_ptr<osg::Camera>& mainCamera();

      virtual void setOverrideCamera(osg::Camera* camera);

      virtual void setMouseX(double x);
      virtual double mouseX() const;
      virtual void setMouseY(double y);
      virtual double mouseY() const;

      virtual void setMousePressed(int button, bool pressed);
      virtual bool mousePressed(int button) const;

      virtual void setMouseWheel(float wheel);
      virtual float mouseWheel() const;

      virtual void AddInputCharacter(char character);

      virtual float dpiScale();
      virtual void setDpiScale(float scale);

      virtual void setRenderVirtualCursor(bool enable);

      static DtImguiDrawable* getInstance(DtDe& de, DtOsgRenderer* renderer);

      static DtImguiDrawable* getInstance();

      static void resetDpiScaling(DtDe& de, DtOsgRenderer* renderer);

   protected:
      virtual void initImGui();
      virtual bool createFontsTexture();

      virtual bool createDeviceObjects();
      virtual void invalidateDeviceObjects();

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

      virtual void renderDrawLists(ImDrawData* draw_data, osg::State* state);

   private:
      DtImguiDrawable(const DtImguiDrawable& other);
      DtImguiDrawable& operator=(const DtImguiDrawable& other);

   public:
      boost::signalslib::signal<void(osg::RenderInfo&)> signal_imguiNewFrame;

   protected:
      DtDe& myDe;
      std::vector<DtImguiTweakUI*> myUiArray;
      DtImGuiEventProcessor* myEventProcessor;

      // UI Data
      double myTime;
      bool myMousePressed[3];
      float myMouseWheel;
      double myMouseX;
      double myMouseY;

      // Rendering data
      GLuint myFontTexture;
      int myShaderHandle;
      int myVertHandle;
      int myFragHandle;
      int myAttribLocationTex;
      int myAttribLocationProjMtx;
      int myAttribLocationPosition;
      int myAttribLocationUV;
      int myAttribLocationColor;
      unsigned int myVboHandle;
      unsigned int myVaoHandle;
      unsigned int myElementsHandle;
      int myInitialized;
      mutable bool myMutableFirstFrame;

      // wrapper to not indirectly include glx.h for linux everywhere else
      DtGlContextWrapper* myContextIDWrapper;

      osg::observer_ptr<osg::Camera> myMainCamera;
      osg::observer_ptr<osg::Camera> myOverrideCamera;
      unsigned int myLastFrameNum;

      osg::ref_ptr<osg::BlendEquation> myBlendEquation;
      osg::ref_ptr<osg::BlendFunc> myBlendFunc;
      osg::ref_ptr<osg::BlendFunc> myVrBlendFunc;
      bool myLastHdrSetting;
      bool myRenderVirtualCursor;
      std::vector<char> myCharacters;
      float myDpiScale;

      NetworkMonitorGui* myOsgEarthNetworkMonitor;
   protected:

      static DtImguiDrawable* theImguiInstance;
   };

};