TGOSXGL.mm

Go to the documentation of this file.

#include <utility>
#include <cassert>
#include <vector>
 
#include <Foundation/Foundation.h>
 
#include "TVirtualViewer3D.h"
#include "TSeqCollection.h"
#include "TVirtualGL.h"
#include "TVirtualX.h"
#include "TGOSXGL.h"
#include "TROOT.h"
#include "TEnv.h"
 
 
ClassImp(TGOSXGLManager)
 
//______________________________________________________________________________
TGOSXGLManager::TGOSXGLManager()
{
   //Constructor.
 
   //gGLManager is a singleton, it's created by the plugin manager
   //(either from TRootCanvas or TRootEmbeddedCanvas),
   //never by user.
 
   assert(gGLManager == 0 && "TGOSXGLManager, gGLManager is initialized");
   gGLManager = this;
 
   if (gROOT && gROOT->GetListOfSpecials())
      gROOT->GetListOfSpecials()->Add(this);
}
 
 
//______________________________________________________________________________
TGOSXGLManager::~TGOSXGLManager()
{
   //Destructor.
 
   if (gROOT && gROOT->GetListOfSpecials())
      gROOT->GetListOfSpecials()->Remove(this);
}
 
 
//______________________________________________________________________________
Int_t TGOSXGLManager::InitGLWindow(Window_t parentID)
{
   typedef std::pair<UInt_t, Int_t> component_type;
 
   std::vector<component_type> format;//Where is the hummer when you need one??? (I mean C++11 initializers '{xxx}').
 
   format.push_back(component_type(Rgl::kDoubleBuffer, 1));//1 means nothing, kDoubleBuffer is enough :)
   format.push_back(component_type(Rgl::kStencil, 8));
   format.push_back(component_type(Rgl::kDepth, 32));
 
   if (gEnv) {
      const Int_t nSamples = gEnv->GetValue("OpenGL.Framebuffer.Multisample", 0);
      if (nSamples > 0 && nSamples <= 8) //TODO: check the 'upper limit' using API, not hardcoded 8.
         format.push_back(component_type(Rgl::kMultiSample, nSamples));
   }
 
   //Now, the interface is quite ugly, that's why it's called TVirtualX :)
   Int_t x = 0, y = 0;
   UInt_t width = 0, height = 0;
   gVirtualX->GetWindowSize(parentID, x, y, width, height);
 
   const Window_t glWin = gVirtualX->CreateOpenGLWindow(parentID, width, height, format);
   if (glWin != kNone) {
      //TRootCanvas/TRootEmbeddedCanvas never do this,
      //so ...
      gVirtualX->MapWindow(glWin);
   }
 
   //Window_t is long, in principle it's a potential problem: do I need a mapping?
   //But if you have billions of windows ... ;)
   return Int_t(glWin);
}
 
 
//______________________________________________________________________________
Int_t TGOSXGLManager::CreateGLContext(Int_t winID)
{
   //Called from TRootCanvas, it never shares :) -> the second parameter is kNone.
   //Handle_t is long, I'm converting to int, which can be a problem if you ...
   //have billions of gl contexts :)
   const Handle_t ctx = gVirtualX->CreateOpenGLContext(winID, kNone);
   fCtxToWin[ctx] = Window_t(winID);
 
   return Int_t(ctx);
}
 
//______________________________________________________________________________
void TGOSXGLManager::DeleteGLContext(Int_t ctxInd)
{
   //Just delegate.
   gVirtualX->DeleteOpenGLContext(ctxInd);
}
 
//______________________________________________________________________________
Bool_t TGOSXGLManager::MakeCurrent(Int_t ctxInd)
{
   assert(fCtxToWin.find(Handle_t(ctxInd)) != fCtxToWin.end() &&
          "MakeCurrent, window not found for a given context");
 
   return gVirtualX->MakeOpenGLContextCurrent(Handle_t(ctxInd), fCtxToWin[Handle_t(ctxInd)]);
}
 
//______________________________________________________________________________
void TGOSXGLManager::Flush(Int_t ctxInd)
{
   gVirtualX->FlushOpenGLBuffer(ctxInd);
}
 
 
//______________________________________________________________________________
Int_t TGOSXGLManager::GetVirtualXInd(Int_t ctxInd)
{
   return ctxInd;
}
 
//A bunch of (now) noop functions - this is a legacy from the time when
//we had a real off-screen OpenGL rendering. Nowadays we always do it "on-screen"
 
//______________________________________________________________________________
Bool_t TGOSXGLManager::AttachOffScreenDevice(Int_t, Int_t, Int_t, UInt_t, UInt_t)
{
   //NOOP.
   return kFALSE;
}
 
 
//______________________________________________________________________________
Bool_t TGOSXGLManager::ResizeOffScreenDevice(Int_t, Int_t, Int_t, UInt_t, UInt_t)
{
   //NOOP.
   return kFALSE;
}
 
 
//______________________________________________________________________________
void TGOSXGLManager::SelectOffScreenDevice(Int_t)
{
   //NOOP.
}
 
 
//______________________________________________________________________________
void TGOSXGLManager::MarkForDirectCopy(Int_t, Bool_t)
{
   //NOOP.
}
 
//______________________________________________________________________________
void TGOSXGLManager::ExtractViewport(Int_t, Int_t *)
{
   //NOOP.
}
 
//______________________________________________________________________________
void TGOSXGLManager::ReadGLBuffer(Int_t)
{
   //NOOP.
}
 
//These 'delegating' functions are legacy - were required (many years ago) on Windows.
 
//______________________________________________________________________________
Bool_t TGOSXGLManager::SelectManip(TVirtualGLManip *manip, const TGLCamera *camera, const TGLRect *rect, const TGLBoundingBox *sceneBox)
{
   //Why all this mess with pointers/references and not pointers/references everywhere???
 
   assert(manip != 0 && "SelectManip, parameter 'manip' is null");
   assert(camera != 0 && "SelectManip, parameter 'camera' is null");
   assert(rect != 0 && "SelectManip, parameter 'rect' is null");
   assert(sceneBox != 0 && "SelectManip, parameter 'sceneBox' is null");
 
   // Select manipulator.
   return manip->Select(*camera, *rect, *sceneBox);
}
 
//______________________________________________________________________________
Bool_t TGOSXGLManager::PlotSelected(TVirtualGLPainter *plot, Int_t px, Int_t py)
{
   //Analog of TObject::DistancetoPrimitive
   assert(plot != 0 && "PlotSelected, parameter 'plot' is null");
 
   return plot->PlotSelected(px, py);
}
 
//______________________________________________________________________________
char *TGOSXGLManager::GetPlotInfo(TVirtualGLPainter *plot, Int_t px, Int_t py)
{
   //Analog of TObject::GetObjectInfo
   assert(plot != 0 && "GetPlotInfo, parameter 'plot' is null");
 
   return plot->GetPlotInfo(px, py);
}
 
//______________________________________________________________________________
void TGOSXGLManager::PaintSingleObject(TVirtualGLPainter *p)
{
   // Paint a single object.
   assert(p != 0 && "PaintSingleObject, parameter 'p' is null");
 
   p->Paint();
}
 
//______________________________________________________________________________
void TGOSXGLManager::PanObject(TVirtualGLPainter *object, Int_t x, Int_t y)
{
   // Pan objects.
   assert(object != 0 && "PanObject, parameter 'object' is null");
 
   return object->Pan(x, y);
}
 
//______________________________________________________________________________
void TGOSXGLManager::PrintViewer(TVirtualViewer3D *vv)
{
   // Print viewer.
   assert(vv != 0 && "PrintViewer, parameter 'vv' is null");
 
   vv->PrintObjects();
}