TGLPadPainter.cxx

Go to the documentation of this file.

// @(#)root/gl:$Id$
// Author:  Timur Pocheptsov  06/05/2009
 
/*************************************************************************
 * Copyright (C) 1995-2009, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include <stdexcept>
#include <cassert>
#include <limits>
#include <memory>
#include <vector>
 
#include "TAttMarker.h"
#include "TVirtualX.h"
#include "TError.h"
#include "TImage.h"
#include "TROOT.h"
#include "TPad.h"
#include "TCanvas.h"
#include "TCanvasImp.h"
#include "TImage.h"
 
#include "TColorGradient.h"
#include "TGLPadPainter.h"
#include "TGLIncludes.h"
#include "TGLUtil.h"
#include "TMath.h"
 
#include <glad/gl.h>
 
namespace {
 
////////////////////////////////////////////////////////////////////////////////
///Not a bad idea to assert on gVirtualX != nullptr
 
bool IsGradientFill(Color_t fillColorIndex)
{
   return dynamic_cast<TColorGradient *>(gROOT->GetColor(fillColorIndex));
}
 
}
 
/** \class TGLPadPainter
\ingroup opengl
"Delegating" part of TGLPadPainter. Line/fill/etc. attributes can be
set inside TPad, but not only there:
many of them are set by base sub-objects of 2d primitives
(2d primitives usually inherit TAttLine or TAttFill etc.).  And these sub-objects
call gVirtualX->SetLineWidth ... etc. So, if I save some attributes in my painter,
it will be mess - at any moment I do not know, where to take line attribute - from
gVirtualX or from my own member. So! All attributed, _ALL_ go to/from gVirtualX.
*/
 
 
////////////////////////////////////////////////////////////////////////////////
 
TGLPadPainter::TGLPadPainter()
                  : fIsHollowArea(kFALSE),
                    fLocked(kTRUE)
{
   fVp[0] = fVp[1] = fVp[2] = fVp[3] = 0;
   fWinContext = 0;
}
 
 
////////////////////////////////////////////////////////////////////////////////
///Delegate to gVirtualX.
 
void TGLPadPainter::SetOpacity(Int_t percent)
{
   // does not work this way
   gVirtualX->SetOpacityW(fWinContext, percent);
}
 
////////////////////////////////////////////////////////////////////////////////
///Delegate to gVirtualX.
 
Float_t TGLPadPainter::GetTextMagnitude() const
{
   return gVirtualX->GetTextMagnitude();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Select pad where current painting will be performed
 
void TGLPadPainter::OnPad(TVirtualPad *pad)
{
   // GL painter does not use proper id for sub-pads (see CreateDrawable)
      // so one always use canvas ID to execute TVirtualX-specific commands
   if (!fWinContext)
      fWinContext = gVirtualX->GetWindowContext(pad->GetCanvasID());
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set fill attributes
 
void TGLPadPainter::SetAttFill(const TAttFill &att)
{
   TPadPainterBase::SetAttFill(att);
 
   fGlFillAtt = GetAttFillInternal(kTRUE);
 
   // TODO: dismiss in the future, gVirtualX attributes not needed in GL
   if (fWinContext && gVirtualX)
      gVirtualX->SetAttFill(fWinContext, att);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set line attributes
 
void TGLPadPainter::SetAttLine(const TAttLine &att)
{
   TPadPainterBase::SetAttLine(att);
 
   // TODO: dismiss in the future, gVirtualX attributes not needed in GL
   if (fWinContext && gVirtualX)
      gVirtualX->SetAttLine(fWinContext, att);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set marker attributes
 
void TGLPadPainter::SetAttMarker(const TAttMarker &att)
{
   TPadPainterBase::SetAttMarker(att);
 
   // TODO: dismiss in the future, gVirtualX attributes not needed in GL
   if (fWinContext && gVirtualX)
      gVirtualX->SetAttMarker(fWinContext, att);
}
 
/*
"Pixmap" part of TGLPadPainter.
*/
 
////////////////////////////////////////////////////////////////////////////////
///Not required at the moment.
 
Int_t TGLPadPainter::CreateDrawable(UInt_t /* w */, UInt_t /* h */)
{
   // return gVirtualX->OpenPixmap(Int_t(w), Int_t(h));
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Resize a gVirtualX Pixmap.
 
Int_t TGLPadPainter::ResizeDrawable(Int_t device, UInt_t w, UInt_t h)
{
   return gVirtualX->ResizePixmap(device, w, h);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Do nothing, sub-pads not cleared in GL
 
void TGLPadPainter::ClearDrawable()
{
}
 
////////////////////////////////////////////////////////////////////////////////
/// Clear specified window - calling gVirtualX->ClearWindowW
 
void TGLPadPainter::ClearWindow(Int_t device)
{
   auto ctxt = gVirtualX->GetWindowContext(device);
   if (ctxt)
      gVirtualX->ClearWindowW(ctxt);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns true when X11 backend is used
 
Bool_t TGLPadPainter::IsX11() const
{
   return gVirtualX->InheritsFrom("TGX11");
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns true when cocoa backend is used
 
Bool_t TGLPadPainter::IsCocoa() const
{
   return gVirtualX->InheritsFrom("TGCocoa");
}
 
////////////////////////////////////////////////////////////////////////////////
///Not required at the moment.
 
void TGLPadPainter::CopyDrawable(Int_t /* device */, Int_t /* px */, Int_t /* py */)
{
   // gVirtualX->CopyPixmapW(fWinContext, device, px, py);
}
 
////////////////////////////////////////////////////////////////////////////////
///Not required at the moment.
 
void TGLPadPainter::DestroyDrawable(Int_t /* device */)
{
   // gVirtualX->SelectWindow(device);
   // gVirtualX->ClosePixmap();
   fWinContext = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
///For gVirtualX this means select pixmap (or window)
///and all subsequent drawings will go into
///this pixmap. For OpenGL this means the change of
///coordinate system and viewport.
 
void TGLPadPainter::SelectDrawable(Int_t /* device */)
{
   auto pad = dynamic_cast<TPad *>(gPad);
   if (!fWinContext && pad)
      fWinContext = gVirtualX->GetWindowContext(pad->GetCanvasID());
 
   if (fLocked)
      return;
 
   if (pad) {
      // GL painter does not use proper id for sub-pads (see CreateDrawable)
      // so one always use canvas ID to execute TVirtualX-specific commands
      Int_t px = 0, py = 0;
 
      pad->XYtoAbsPixel(pad->GetX1(), pad->GetY1(), px, py);
 
      py = gPad->GetWh() - py;
      //
      TGLUtil::InitializeIfNeeded();
      const Float_t scale = TGLUtil::GetScreenScalingFactor();
 
      glViewport(GLint(px * scale), GLint(py * scale),
                 GLsizei(gPad->GetWw() * pad->GetAbsWNDC() * scale),
                 GLsizei(gPad->GetWh() * pad->GetAbsHNDC() * scale));
 
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glOrtho(pad->GetX1(), pad->GetX2(), pad->GetY1(), pad->GetY2(), -10., 10.);
 
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      glTranslated(0., 0., -1.);
   } else {
      ::Error("TGLPadPainter::SelectDrawable",
               "function was called not from TPad or TCanvas code\n");
      throw std::runtime_error("");
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Call low-level update of selected drawable, redirect to gVirtualX.
 
void TGLPadPainter::UpdateDrawable(Int_t mode)
{
   if (fWinContext)
      gVirtualX->UpdateWindowW(fWinContext, mode);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Set drawing mode for specified device
 
void TGLPadPainter::SetDrawMode(Int_t device, Int_t mode)
{
   auto ctxt = fWinContext;
   if (device)
      ctxt = gVirtualX->GetWindowContext(device);
   if (ctxt)
      gVirtualX->SetDrawModeW(ctxt, (TVirtualX::EDrawMode) mode);
}
 
////////////////////////////////////////////////////////////////////////////////
///Init gl-pad painter:
///1. 2D painter does not use depth test, should not modify
///   depth-buffer content (except initial cleanup).
///2. Disable cull face.
///3. Disable lighting.
///4. Set viewport (to the whole canvas area).
///5. Set camera.
///6. Unlock painter.
 
void TGLPadPainter::InitPainter()
{
   static bool gl_init = false;
   if (!gl_init) {
      int version = gladLoaderLoadGL();
      if (version == 0)
         Warning("TGLPadPainter::InitPainter", "GL initalization failed.");
      else if (gDebug > 0)
         Info("TGLPadPainter::InitPainter", "GL initalization successful.");
      gl_init = true;
   }
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_CULL_FACE);
   glDisable(GL_LIGHTING);
 
   //Clear the buffer
   glViewport(0, 0, GLsizei(gPad->GetWw()), GLsizei(gPad->GetWh()));
 
   glDepthMask(GL_TRUE);
   glClearColor(1.,1.,1.,1.);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glDepthMask(GL_FALSE);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   glOrtho(gPad->GetX1(), gPad->GetX2(), gPad->GetY1(), gPad->GetY2(), -10., 10.);
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslated(0., 0., -1.);
 
   fLocked = kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
///When TPad::Range for gPad is called, projection
///must be changed in OpenGL.
 
void TGLPadPainter::InvalidateCS()
{
   if (fLocked) return;
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   glOrtho(gPad->GetX1(), gPad->GetX2(), gPad->GetY1(), gPad->GetY2(), -10., 10.);
 
   glMatrixMode(GL_MODELVIEW);
}
 
////////////////////////////////////////////////////////////////////////////////
///Locked state of painter means, that
///GL context can be invalid, so no GL calls
///can be executed.
 
void TGLPadPainter::LockPainter()
{
   if (fLocked) return;
 
   glFinish();
   fLocked = kTRUE;
}
 
/*
2D primitives.
*/
 
const Double_t lineWidthTS = 3.;
 
////////////////////////////////////////////////////////////////////////////////
///Draw line segment.
 
void TGLPadPainter::DrawLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
{
   if (fLocked) {
      //GL pad painter can be called in non-standard situation:
      //not from TPad::Paint, but
      //from TView3D::ExecuteRotateView. This means in fact,
      //that TView3D wants to draw itself in a XOR mode, via
      //gVirtualX.
      // TODO: only here set line attributes to virtual x
      if (IsInvertMode())
         gVirtualX->DrawLineW(fWinContext,
                             gPad->XtoAbsPixel(x1), gPad->YtoAbsPixel(y1),
                             gPad->XtoAbsPixel(x2), gPad->YtoAbsPixel(y2));
 
      return;
   }
 
   const Rgl::Pad::LineAttribSet lineAttribs(kTRUE, GetAttLine().GetLineStyle(), fLimits.GetMaxLineWidth(), kTRUE, &GetAttLine());
 
   glBegin(GL_LINES);
   glVertex2d(x1, y1);
   glVertex2d(x2, y2);
   glEnd();
 
   if (GetAttLine().GetLineWidth() > lineWidthTS) {
      Double_t pointSize = GetAttLine().GetLineWidth();
      if (pointSize > fLimits.GetMaxPointSize())
         pointSize = fLimits.GetMaxPointSize();
      glPointSize((GLfloat)pointSize);
      const TGLEnableGuard pointSmooth(GL_POINT_SMOOTH);
      glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
      glBegin(GL_POINTS);
 
      glVertex2d(x1, y1);
      glVertex2d(x2, y2);
 
      glEnd();
      glPointSize(1.f);
   }
 
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw line segment in NDC coordinates.
 
void TGLPadPainter::DrawLineNDC(Double_t u1, Double_t v1, Double_t u2, Double_t v2)
{
   if (fLocked) {
      // this code used when crosshair cursor is drawn or interactive objects move
      if (IsInvertMode())
         gVirtualX->DrawLineW(fWinContext,
                              gPad->UtoAbsPixel(u1), gPad->VtoAbsPixel(v1),
                              gPad->UtoAbsPixel(u2), gPad->VtoAbsPixel(v2));
      return;
   }
 
   const Rgl::Pad::LineAttribSet lineAttribs(kTRUE, GetAttLine().GetLineStyle(), fLimits.GetMaxLineWidth(), kTRUE, &GetAttLine());
   const Double_t xRange = gPad->GetX2() - gPad->GetX1();
   const Double_t yRange = gPad->GetY2() - gPad->GetY1();
 
   glBegin(GL_LINES);
   glVertex2d(gPad->GetX1() + u1 * xRange, gPad->GetY1() + v1 * yRange);
   glVertex2d(gPad->GetX1() + u2 * xRange, gPad->GetY1() + v2 * yRange);
   glEnd();
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw filled or hollow box.
 
void TGLPadPainter::DrawBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, EBoxMode mode)
{
   if (fLocked) {
      //GL pad painter can be called in non-standard situation:
      //not from TPad::Paint, but
      //from TView3D::ExecuteRotateView. This means in fact,
      //that TView3D wants to draw itself in a XOR mode, via
      //gVirtualX.
      // TODO: only here set line attributes to virtual x
      if (IsInvertMode())
         gVirtualX->DrawBoxW(fWinContext,
                             gPad->XtoAbsPixel(x1), gPad->YtoAbsPixel(y1),
                             gPad->XtoAbsPixel(x2), gPad->YtoAbsPixel(y2),
                             (TVirtualX::EBoxMode) mode);
      return;
   }
 
   if (IsGradientFill(fGlFillAtt.GetFillColor())) {
      Double_t xs[] = {x1, x2, x2, x1};
      Double_t ys[] = {y1, y1, y2, y2};
      DrawPolygonWithGradient(4, xs, ys);
      return;
   }
 
   if (mode == kHollow) {
      const Rgl::Pad::LineAttribSet lineAttribs(kTRUE, 0, fLimits.GetMaxLineWidth(), kTRUE, &GetAttLine());
      glBegin(GL_LINE_LOOP);
      glVertex2d(x1, y1);
      glVertex2d(x2, y1);
      glVertex2d(x2, y2);
      glVertex2d(x1, y2);
      glEnd();
   } else {
      const Rgl::Pad::FillAttribSet fillAttribs(fSSet, kFALSE, &fGlFillAtt);//Set filling parameters.
      glRectd(x1, y1, x2, y2);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw tesselated polygon (probably, outline only).
 
void TGLPadPainter::DrawFillArea(Int_t n, const Double_t *x, const Double_t *y)
{
   assert(x != nullptr && "DrawFillArea, parameter 'x' is null");
   assert(y != nullptr && "DrawFillArea, parameter 'y' is null");
 
   if (fLocked)
      return;
 
   if (n < 3) {
      ::Error("TGLPadPainter::DrawFillArea",
              "invalid number of points in a polygon");
      return;
   }
 
   if (IsGradientFill(fGlFillAtt.GetFillColor()))
      return DrawPolygonWithGradient(n, x, y);
 
   if (fFullyTransparent) {
      fIsHollowArea = kTRUE;
      return DrawPolyLine(n, x, y);
   }
 
   const Rgl::Pad::FillAttribSet fillAttribs(fSSet, kFALSE, &fGlFillAtt);
   DrawTesselation(n, x, y);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw tesselated polygon (never called, probably, since TPad::PaintFillArea for floats
///is deprecated).
 
void TGLPadPainter::DrawFillArea(Int_t n, const Float_t *x, const Float_t *y)
{
   if (fLocked) return;
 
   if (fFullyTransparent) {
      fIsHollowArea = kTRUE;
      return DrawPolyLine(n, x, y);
   }
 
   fVs.resize(n * 3);
 
   for (Int_t i = 0; i < n; ++i) {
      fVs[i * 3]     = x[i];
      fVs[i * 3 + 1] = y[i];
   }
 
   const Rgl::Pad::FillAttribSet fillAttribs(fSSet, kFALSE, &fGlFillAtt);
 
   GLUtesselator *t = (GLUtesselator *)fTess.GetTess();
   gluBeginPolygon(t);
   gluNextContour(t, (GLenum)GLU_UNKNOWN);
 
   for (Int_t i = 0; i < n; ++i)
      gluTessVertex(t, &fVs[i * 3], &fVs[i * 3]);
 
 
   gluEndPolygon(t);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw poly-line in user coordinates.
 
template<class ValueType>
void TGLPadPainter::DrawPolyLineHelper(Int_t n, const ValueType *x, const ValueType *y)
{
   if (fLocked) {
      if (IsInvertMode() && (n > 1)) {
         std::vector<TPoint> xy(n);
         for (Int_t i = 0; i < n; ++i) {
            xy[i].fX = (SCoord_t) gPad->XtoAbsPixel(x[i]);
            xy[i].fY = (SCoord_t) gPad->YtoAbsPixel(y[i]);
         }
         gVirtualX->DrawPolyLineW(fWinContext, xy.size(), xy.data());
      }
      return;
   }
 
   const Rgl::Pad::LineAttribSet lineAttribs(kTRUE, GetAttLine().GetLineStyle(), fLimits.GetMaxLineWidth(), kTRUE, &GetAttLine());
 
   glBegin(GL_LINE_STRIP);
 
   for (Int_t i = 0; i < n; ++i)
      glVertex2d(x[i], y[i]);
 
   if (fIsHollowArea) {
      glVertex2d(x[0], y[0]);
      fIsHollowArea = kFALSE;
   }
   glEnd();
 
   if (GetAttLine().GetLineWidth() > lineWidthTS) {
      Double_t pointSize = GetAttLine().GetLineWidth();
      if (pointSize > fLimits.GetMaxPointSize())
         pointSize = fLimits.GetMaxPointSize();
      glPointSize((GLfloat)pointSize);
      const TGLEnableGuard pointSmooth(GL_POINT_SMOOTH);
      glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
      glBegin(GL_POINTS);
 
      for (Int_t i = 0; i < n; ++i)
         glVertex2d(x[i], y[i]);
 
      glEnd();
      glPointSize(1.f);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw poly-line in user coordinates.
 
void TGLPadPainter::DrawPolyLine(Int_t n, const Double_t *x, const Double_t *y)
{
   DrawPolyLineHelper(n, x, y);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw poly-line in user coordinates.
 
void TGLPadPainter::DrawPolyLine(Int_t n, const Float_t *x, const Float_t *y)
{
   DrawPolyLineHelper(n, x, y);
}
 
////////////////////////////////////////////////////////////////////////////////
///Poly line in NDC.
 
void TGLPadPainter::DrawPolyLineNDC(Int_t n, const Double_t *u, const Double_t *v)
{
   if (fLocked) return;
 
   const Rgl::Pad::LineAttribSet lineAttribs(kTRUE, GetAttLine().GetLineStyle(), fLimits.GetMaxLineWidth(), kTRUE, &GetAttLine());
   const Double_t xRange = gPad->GetX2() - gPad->GetX1();
   const Double_t yRange = gPad->GetY2() - gPad->GetY1();
   const Double_t x1 = gPad->GetX1(), y1 = gPad->GetY1();
 
   glBegin(GL_LINE_STRIP);
 
   for (Int_t i = 0; i < n; ++i)
      glVertex2d(x1 + u[i] * xRange, y1 + v[i] * yRange);
 
   glEnd();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns true when invert mode is configured and painter in locked state
/// Used when non-opaque of objects moving is involved
 
Bool_t TGLPadPainter::IsInvertMode()
{
   return fWinContext && (gVirtualX->GetDrawModeW(fWinContext) == TVirtualX::kInvert);
}
 
////////////////////////////////////////////////////////////////////////////////
///Poly-marker drawing
 
template<class ValueType>
void TGLPadPainter::DrawPolyMarkerHelper(Int_t n, const ValueType *x, const ValueType *y)
{
   std::vector<TPoint> poly(n);
 
   if (fLocked) {
      if (IsInvertMode()) {
         for (Int_t i = 0; i < n; ++i) {
            poly[i].fX = gPad->XtoAbsPixel(x[i]);
            poly[i].fY = gPad->YtoAbsPixel(y[i]);
         }
         gVirtualX->DrawPolyMarkerW(fWinContext, poly.size(), poly.data());
      }
      return;
   }
 
   const UInt_t padH = gPad->GetPadHeight();
 
   for (Int_t i = 0; i < n; ++i) {
      poly[i].fX = gPad->XtoPixel(x[i]);
      poly[i].fY = padH - gPad->YtoPixel(y[i]);
   }
 
   SaveProjectionMatrix();
   glLoadIdentity();
   //
   glOrtho(0, gPad->GetPadWidth(), 0, gPad->GetPadHeight(), -10., 10.);
   //
   glMatrixMode(GL_MODELVIEW);
   //
   const TGLEnableGuard blendGuard(GL_BLEND);
 
   Float_t rgba[4] = {};
   Rgl::Pad::ExtractRGBA(GetAttMarker().GetMarkerColor(), rgba);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glColor4fv(rgba);
 
   const Width_t w = TMath::Max(1, Int_t(TAttMarker::GetMarkerLineWidth(GetAttMarker().GetMarkerStyle())));
   glLineWidth(w > fLimits.GetMaxLineWidth() ? fLimits.GetMaxLineWidth() : !w ? 1.f : w);
 
   Rgl::Pad::MarkerPainter::DrawMarkers(n, poly.data(), GetAttMarker());
 
   RestoreProjectionMatrix();
   glMatrixMode(GL_MODELVIEW);
   glLineWidth(1.f);
}
 
////////////////////////////////////////////////////////////////////////////////
///Poly-marker.
 
void TGLPadPainter::DrawPolyMarker(Int_t n, const Double_t *x, const Double_t *y)
{
   DrawPolyMarkerHelper(n, x, y);
}
 
////////////////////////////////////////////////////////////////////////////////
///Poly-marker.
 
void TGLPadPainter::DrawPolyMarker(Int_t n, const Float_t *x, const Float_t *y)
{
   DrawPolyMarkerHelper(n, x, y);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Select specified font/size
 
void TGLPadPainter::SelectGLFont(Font_t font, Float_t tsize)
{
   //10 is the first valid font index.
   //20 is FreeSerifBold, as in TTF.cxx and in TGLFontManager.cxx.
   //shift - is the shift to access "extended" fonts.
   const Int_t shift = TGLFontManager::GetExtendedFontStartIndex();
 
   Int_t fontIndex = TMath::Max(Font_t(10), font);
   if (fontIndex / 10 + shift > TGLFontManager::GetFontFileArray()->GetEntries())
      fontIndex = 20 + shift * 10;
   else
      fontIndex += shift * 10;
 
   Int_t textSize = TMath::Max(Int_t(tsize) - 1, 10);
 
   const char *name = TGLFontManager::GetFontNameFromId(fontIndex);
 
   fFM.RegisterFont(textSize, name, TGLFont::kTexture, fF);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Indicate that TTF can be used for text metrics
/// Drawing done with FTGL which is based on Freetype library
 
Bool_t TGLPadPainter::HasTTFonts() const
{
   return kTRUE;
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Helper function to draw text
 
template<class Char>
void TGLPadPainter::DrawTextHelper(Double_t x, Double_t y, const Char *text, ETextMode /*mode*/)
{
   SaveProjectionMatrix();
 
   glLoadIdentity();
   //
   glOrtho(0, gPad->GetAbsWNDC() * gPad->GetWw(), 0, gPad->GetAbsHNDC() * gPad->GetWh(), -10., 10.);
   //
   glMatrixMode(GL_MODELVIEW);
 
   Float_t rgba[4] = {};
   Rgl::Pad::ExtractRGBA(GetAttText().GetTextColor(), rgba);
   glColor4fv(rgba);
 
   SelectGLFont(GetAttText().GetTextFont(), GetAttText().GetTextSizePixels(*gPad));
 
   fF.SetTextAlign(GetAttText().GetTextAlign());
 
   fF.PreRender();
 
   const UInt_t padH = UInt_t(gPad->GetAbsHNDC() * gPad->GetWh());
   fF.Render(text, gPad->XtoPixel(x), padH - gPad->YtoPixel(y), GetTextAngle(), GetTextMagnitude());
 
   fF.PostRender();
   RestoreProjectionMatrix();
 
   glMatrixMode(GL_MODELVIEW);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw text. This operation is especially
///dangerous if in locked state -
///ftgl will assert on zero texture size
///(which is result of bad GL context).
 
void TGLPadPainter::DrawText(Double_t x, Double_t y, const char *text, ETextMode mode)
{
   if (fLocked) return;
 
   if (GetAttText().GetTextSize() > 0)
      DrawTextHelper(x, y, text, mode);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw text. This operation is especially
///dangerous if in locked state -
///ftgl will assert on zero texture size
///(which is result of bad GL context).
 
void TGLPadPainter::DrawText(Double_t x, Double_t y, const wchar_t *text, ETextMode mode)
{
   if (fLocked) return;
 
   if (GetAttText().GetTextSize() > 0)
      DrawTextHelper(x, y, text, mode);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw text in NDC. This operation is especially
///dangerous if in locked state -
///ftgl will assert on zero texture size
///(which is result of bad GL context).
 
void TGLPadPainter::DrawTextNDC(Double_t u, Double_t v, const char *text, ETextMode mode)
{
   if (fLocked) return;
 
   const Double_t xRange = gPad->GetX2() - gPad->GetX1();
   const Double_t yRange = gPad->GetY2() - gPad->GetY1();
   DrawText(gPad->GetX1() + u * xRange, gPad->GetY1() + v * yRange, text, mode);
}
 
////////////////////////////////////////////////////////////////////////////////
///Draw text in NDC. This operation is especially
///dangerous if in locked state -
///ftgl will assert on zero texture size
///(which is result of bad GL context).
 
void TGLPadPainter::DrawTextNDC(Double_t u, Double_t v, const wchar_t *text, ETextMode mode)
{
   if (fLocked) return;
 
   const Double_t xRange = gPad->GetX2() - gPad->GetX1();
   const Double_t yRange = gPad->GetY2() - gPad->GetY1();
   DrawText(gPad->GetX1() + u * xRange, gPad->GetY1() + v * yRange, text, mode);
}
 
////////////////////////////////////////////////////////////////////////////////
///Save the projection matrix.
///Attention! GL_PROJECTION will become the current matrix
///after this call!
 
void TGLPadPainter::SaveProjectionMatrix()const
{
   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
///Restore the projection matrix.
///Attention! GL_PROJECTION will become the current matrix
///after this call!
 
void TGLPadPainter::RestoreProjectionMatrix()const
{
   glMatrixMode(GL_PROJECTION);
   glPopMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
///Save the modelview matrix.
///Attention! GL_MODELVIEW will become the current matrix
///after this call!
 
void TGLPadPainter::SaveModelviewMatrix()const
{
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
///Restore the modelview matrix.
///Attention! GL_MODELVIEW will become the current matrix
///after this call!
 
void TGLPadPainter::RestoreModelviewMatrix()const
{
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
///Extract and save the current viewport.
 
void TGLPadPainter::SaveViewport()
{
   glGetIntegerv(GL_VIEWPORT, fVp);
}
 
////////////////////////////////////////////////////////////////////////////////
///Restore the saved viewport.
 
void TGLPadPainter::RestoreViewport()
{
   glViewport(fVp[0], fVp[1], fVp[2], fVp[3]);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Draw image on the GL window
 
void TGLPadPainter::DrawImage(TImage *img, Int_t dstX, Int_t dstY, Int_t flags)
{
   if (fLocked)
      return;
 
   auto width = img->GetWidth();
   auto height = img->GetHeight();
   auto pixelData = (unsigned char *) img->GetArgbArray();
 
   if (!pixelData) {
      ::Error("TGLPadPainter::DrawImage", "pixel data is null");
      return;
   }
 
   if (!width || !height) {
      //Assert is better.
      ::Error("TGLPadPainter::DrawImage", "invalid image dimentsion");
      return;
   }
 
   if (!gPad) {
      ::Error("TGLPadPainter::DrawImage", "pad is not provided");
      return;
   }
 
   const Double_t rasterX = Double_t(dstX) / gPad->GetPadWidth() * (gPad->GetX2() - gPad->GetX1()) + gPad->GetX1();
 
   const Double_t yRange = gPad->GetY2() - gPad->GetY1();
   const Double_t rasterY = yRange - Double_t(dstY + height) / gPad->GetPadHeight() * yRange + gPad->GetY1();
 
   GLdouble oldPos[4] = {};
   // Save the previous raster pos.
   glGetDoublev(GL_CURRENT_RASTER_POSITION, oldPos);
 
   glRasterPos2d(rasterX, rasterY);
   // Stupid asimage provides us upside-down image.
   std::vector<unsigned char> upsideDownImage(4 * width * height);
   const unsigned char *srcLine = pixelData + 4 * width * (height - 1);
   unsigned char *dstLine = &upsideDownImage[0];
   for (UInt_t i = 0; i < height; ++i, srcLine -= 4 * width, dstLine += 4 * width)
      std::copy(srcLine, srcLine + 4 * width, dstLine);
 
   if (flags) {
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   }
 
   glDrawPixels(width, height, GL_BGRA, GL_UNSIGNED_BYTE, &upsideDownImage[0]);
 
   if (flags)
      glDisable(GL_BLEND);
 
   //Restore raster pos.
   glRasterPos2d(oldPos[0], oldPos[1]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fill image object with the pixel data from the pad
/// Implements special handling for X11 where ASImage has native implementation
 
Bool_t TGLPadPainter::FillImageFromPad(TImage *image, TVirtualPad *pad) const
{
   auto canvas = pad ? pad->GetCanvas() : nullptr;
   if (!canvas || !image)
      return kFALSE;
 
   UInt_t width  = canvas->GetPadWidth(), height = canvas->GetPadHeight();
   Int_t x0 = 0, y0 = 0;
 
   if (pad != canvas) {
      // GL always paint complete canvas - just extract part out of the complete buffer
      UInt_t pad_width = pad->GetPadWidth();
      UInt_t pad_height = pad->GetPadHeight();
      if (!pad_width || !pad_height) {
         Error("FillImageFromPad", "Pad dimensions are zero");
         return kFALSE;
      }
 
      x0 = TMath::Max(0, pad->UtoAbsPixel(0));
      y0 = TMath::Max(0, pad->VtoAbsPixel(1));
      if ((x0 + pad_width > width) || (y0 + pad_height > height)) {
         Error("FillImageFromPad", "Pad dimensions exceed canvas size");
         return kFALSE;
      }
 
      // because of GL lines swapping need to recalculate first line
      y0 = height - (y0 + pad_height);
 
      width = pad_width;
      height = pad_height;
   }
 
   // special mode to request window attributes, implemented only in TRootCanvas
   Int_t update_arg = 101;
   // on Mac redo update again - no other way found to get GL image updated
   if (IsCocoa()) {
      canvas->Update();
      update_arg = 1;
   }
 
   canvas->GetCanvasImp()->UpdateDisplay(update_arg, kFALSE);
 
#ifndef WIN32
   // crash on Windows
   glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
#endif
 
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glReadBuffer(GL_BACK);
 
   //In case GL_BGRA is not in gl.h (old windows' gl) - comment/uncomment lines.
   //glReadPixels(0, 0, canvas->GetWw(), canvas->GetWh(), GL_BGRA, GL_UNSIGNED_BYTE, (char *)&buff[0]);
 
   std::vector<unsigned> buff(width * height);
 
   glReadPixels(x0, y0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, (char *) buff.data());
 
   TGLUtil::SwapPixelBuffer((UChar_t *) buff.data(), width, height);
 
   // convert rgba into bgra
   for (auto &pix : buff)
      pix = ((pix & 0xff) << 16) | (pix & 0xff00) | ((pix & 0xff0000) >> 16) | (pix & 0xff000000);
 
   image->FromBitmap((UChar_t *) buff.data(), width, height);
 
   return image->IsValid();
}
 
 
////////////////////////////////////////////////////////////////////////////////
 
void TGLPadPainter::DrawPixels(const unsigned char *, UInt_t, UInt_t,
                               Int_t, Int_t, Bool_t)
{
}
 
//Aux. functions - gradient and solid fill of arbitrary area.
 
////////////////////////////////////////////////////////////////////////////////
///At the moment I assume both linear and radial gradients will work the same way  -
///using a stencil buffer and some big rectangle(s) to fill with a gradient.
///Thus I have a 'common' part - the part responsible for a stencil test.
 
void TGLPadPainter::DrawPolygonWithGradient(Int_t n, const Double_t *x, const Double_t *y)
{
   assert(n > 2 && "DrawPolygonWithGradient, invalid number of points");
   assert(x != nullptr && "DrawPolygonWithGradient, parameter 'x' is null");
   assert(y != nullptr && "DrawPolygonWithGradient, parameter 'y' is null");
 
   auto grad = dynamic_cast<TColorGradient *>(gROOT->GetColor(fGlFillAtt.GetFillColor()));
   assert(grad != nullptr && "DrawPolygonWithGradient, the current fill color is not a gradient fill");
 
   if (fLocked)
      return;
 
   //Now, some magic!
   const TGLEnableGuard stencilGuard(GL_STENCIL_TEST);
 
   //TODO: check that the state is restored back correctly after
   //      we done with a gradient.
   //TODO: make sure that we have glDepthMask set to false in general!
   glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
   glStencilFunc(GL_NEVER, 1, 0xFF);
   glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);// draw 1s on test fail (always)
   //Draw stencil pattern
   glStencilMask(0xFF);
   glClear(GL_STENCIL_BUFFER_BIT);
 
   //Draw our polygon into the stencil buffer:
   DrawTesselation(n, x, y);
 
   glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
   glStencilMask(0x00);
   //Draw where stencil's value is 0
   glStencilFunc(GL_EQUAL, 0, 0xFF);
   //Draw only where stencil's value is 1
   glStencilFunc(GL_EQUAL, 1, 0xFF);
 
   //At the moment radial gradient is derived from linear - it was convenient
   //at some point, but in fact it was a bad idea. And now I have to
   //first check radial gradient.
   //TODO: TRadialGradient must inherit TColorGradient directly.
   const TRadialGradient * const rGrad = dynamic_cast<const TRadialGradient *>(grad);
   if (rGrad)
      DrawGradient(rGrad, n, x, y);
   else {
      const TLinearGradient * const lGrad = dynamic_cast<const TLinearGradient *>(grad);
      assert(lGrad != nullptr && "DrawPolygonWithGradient, unknown gradient type");
      DrawGradient(lGrad, n, x, y);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
 
void TGLPadPainter::DrawGradient(const TRadialGradient *grad, Int_t nPoints,
                                 const Double_t *xs, const Double_t *ys)
{
   assert(grad != nullptr && "DrawGradient, parameter 'grad' is null");
   assert(nPoints > 2 && "DrawGradient, invalid number of points");
   assert(xs != nullptr && "DrawGradient, parameter 'xs' is null");
   assert(ys != nullptr && "DrawGradient, parameter 'ys' is null");
 
   if (grad->GetGradientType() != TRadialGradient::kSimple) {
      ::Warning("TGLPadPainter::DrawGradient",
                "extended radial gradient is not supported");//yet?
      return;
   }
 
   //TODO: check the polygon's bbox!
   const auto &bbox = Rgl::Pad::FindBoundingRect(nPoints, xs, ys);
   //
   auto center = grad->GetCenter();
   auto radius = grad->GetRadius();
   //Adjust the center and radius depending on coordinate mode.
   if (grad->GetCoordinateMode() == TColorGradient::kObjectBoundingMode) {
      radius *= TMath::Max(bbox.fWidth, bbox.fHeight);
      center.fX = bbox.fWidth * center.fX + bbox.fXMin;
      center.fY = bbox.fHeight * center.fY + bbox.fYMin;
   } else {
      const auto w = gPad->GetX2() - gPad->GetX1();
      const auto h = gPad->GetY2() - gPad->GetY1();
 
      radius *= TMath::Max(w, h);
      center.fX *= w;
      center.fY *= h;
   }
   //Now for the gradient fill we switch into pixel coordinates:
   const auto pixelW = gPad->GetAbsWNDC() * gPad->GetWw();
   const auto pixelH = gPad->GetAbsHNDC() * gPad->GetWh();
   //
   SaveProjectionMatrix();
   SaveModelviewMatrix();
   //A new ortho projection:
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   //
   glOrtho(0., pixelW, 0., pixelH, -10., 10.);
   //
   radius *= TMath::Max(pixelH, pixelW);
   center.fX = gPad->XtoPixel(center.fX);
   center.fY = pixelH - gPad->YtoPixel(center.fY);
 
   Double_t maxR = 0.;
   {
   const Double_t xMin = gPad->XtoPixel(bbox.fXMin);
   const Double_t xMax = gPad->XtoPixel(bbox.fXMax);
   const Double_t yMin = pixelH - gPad->YtoPixel(bbox.fYMin);
   const Double_t yMax = pixelH - gPad->YtoPixel(bbox.fYMax);
   //Get the longest distance from the center to the bounding box vertices
   //(this will be the maximum possible radius):
   const Double_t maxDistX = TMath::Max(TMath::Abs(center.fX - xMin),
                                        TMath::Abs(center.fX - xMax));
   const Double_t maxDistY = TMath::Max(TMath::Abs(center.fY - yMin),
                                        TMath::Abs(center.fY - yMax));
   maxR = TMath::Sqrt(maxDistX * maxDistX + maxDistY * maxDistY);
   }
 
   //If gradient 'stops inside the polygon', we use
   //the solid fill for the area outside of radial gradient:
   const Bool_t solidFillAfter = maxR > radius;
   //We emulate a radial gradient using triangles and linear gradient:
   //TODO: Can be something smarter? (btw even 100 seems to be enough)
   const UInt_t nSlices = 500;
 
   const auto nColors = grad->GetNumberOfSteps();
   //+1 - the strip from the last color's position to radius,
   //and (probably) + 1 for solidFillAfter.
   const auto nCircles = nColors + 1 + solidFillAfter;
 
   //TODO: can locations be outside of [0., 1.] ???
   //at the moment I assume the answer is NO, NEVER.
   const auto locations = grad->GetColorPositions();
   // * 2 below == x,y
   std::vector<Double_t> circles(nSlices * nCircles * 2);
   const Double_t angle = TMath::TwoPi() / nSlices;
 
   //"Main" circles (for colors at locations[i]).
   for (UInt_t i = 0; i < nColors; ++i) {
      const auto circle = &circles[i * nSlices * 2];
      //TODO: either check locations here or somewhere else.
      const auto r = radius * locations[i];
      for (UInt_t j = 0, e = nSlices * 2 - 2; j < e; j += 2) {
         circle[j] = center.fX + r * TMath::Cos(angle * j);
         circle[j + 1] = center.fY + r * TMath::Sin(angle * j);
      }
      //The "closing" vertices:
      circle[(nSlices - 1) * 2] = circle[0];
      circle[(nSlices - 1) * 2 + 1] = circle[1];
   }
 
   {
   //The strip between lastPos and radius:
   const auto circle = &circles[nColors * nSlices * 2];
   for (UInt_t j = 0, e = nSlices * 2 - 2; j < e; j += 2) {
      circle[j] = center.fX + radius * TMath::Cos(angle * j);
      circle[j + 1] = center.fY + radius * TMath::Sin(angle * j);
   }
 
   circle[(nSlices - 1) * 2] = circle[0];
   circle[(nSlices - 1) * 2 + 1] = circle[1];
   }
 
   if (solidFillAfter) {
      //The strip after the radius:
      const auto circle = &circles[(nCircles - 1) * nSlices * 2];
      for (UInt_t j = 0, e = nSlices * 2 - 2; j < e; j += 2) {
         circle[j] = center.fX + maxR * TMath::Cos(angle * j);
         circle[j + 1] = center.fY + maxR * TMath::Sin(angle * j);
      }
 
      circle[(nSlices - 1) * 2] = circle[0];
      circle[(nSlices - 1) * 2 + 1] = circle[1];
   }
 
   //Now we draw:
   //1) triangle fan in the center (from center to the locations[1],
   //   with a solid fill).
   //2) quad strips for colors.
   //3) additional quad strip from the lastLocation to the radius
   //4) additional quad strip (if any) from the radius to maxR.
 
   //RGBA values:
   const auto rgba = grad->GetColors();
 
   const TGLEnableGuard alphaGuard(GL_BLEND);
   //TODO?
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   //Probably a degenerated case. Maybe not.
   glBegin(GL_TRIANGLE_FAN);
   glColor4dv(rgba);
   glVertex2d(center.fX, center.fY);
 
   for (UInt_t i = 0, e = nSlices * 2; i < e; i += 2)
      glVertex2dv(&circles[i]);
 
   glEnd();
 
   //No auto for circles, explicit types to have const Double_t * const, not Duble_t * const.
   for (UInt_t i = 0; i < nColors - 1; ++i) {
      const Double_t * const inner = &circles[i * nSlices * 2];
      const auto innerRGBA = rgba + i * 4;
      const auto outerRGBA = rgba + (i + 1) * 4;
      const Double_t * const outer = &circles[(i + 1) * nSlices * 2];
 
      Rgl::DrawQuadStripWithRadialGradientFill(nSlices, inner, innerRGBA, outer, outerRGBA);
   }
 
   //Probably degenerated strip.
   {
   const Double_t * const inner = &circles[nSlices * (nColors - 1) * 2];
   const auto solidRGBA = rgba + (nColors - 1) * 4;
   const Double_t * const outer = &circles[nSlices * nColors * 2];
 
   Rgl::DrawQuadStripWithRadialGradientFill(nSlices, inner, solidRGBA, outer, solidRGBA);
   }
 
   if (solidFillAfter) {
      const Double_t * const inner = &circles[nSlices * nColors * 2];
      const auto solidRGBA = rgba + (nColors - 1) * 4;
      const Double_t * const outer = &circles[nSlices * (nColors + 1) * 2];
 
      Rgl::DrawQuadStripWithRadialGradientFill(nSlices, inner, solidRGBA, outer, solidRGBA);
   }
 
   RestoreProjectionMatrix();
   RestoreModelviewMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
 
void TGLPadPainter::DrawGradient(const TLinearGradient *grad, Int_t n,
                                 const Double_t *x, const Double_t *y)
{
   assert(grad != nullptr && "DrawGradient, parameter 'grad' is null");
   assert(n > 2 && "DrawGradient, invalid number of points");
   assert(x != nullptr && "DrawGradient, parameter 'x' is null");
   assert(y != nullptr && "DrawGradient, parameter 'y' is null");
 
   //Now we fill the whole scene with one big rectangle
   //(group of rectangles) with a gradient fill using
   //stencil test.
 
   //Find a bounding rect.
   const auto &bbox = Rgl::Pad::FindBoundingRect(n, x, y);
   //TODO: check the bbox??
 
   //For the gradient fill we switch into the
   //pixel coordinates.
   SaveProjectionMatrix();
   SaveModelviewMatrix();
 
   //A new ortho projection:
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   const Double_t pixelW = gPad->GetAbsWNDC() * gPad->GetWw();
   const Double_t pixelH = gPad->GetAbsHNDC() * gPad->GetWh();
   glOrtho(0., pixelW, 0., pixelH, -10., 10.);
 
   //A new modelview:
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   //
   TColorGradient::Point start = grad->GetStart();
   TColorGradient::Point end   = grad->GetEnd();
 
   //Change gradient coordinates from 'NDC' to pad coords:
   if (grad->GetCoordinateMode() == TColorGradient::kPadMode)
   {
      const Double_t w = gPad->GetX2() - gPad->GetX1();
      const Double_t h = gPad->GetY2() - gPad->GetY1();
 
      start.fX = start.fX * w;
      start.fY = start.fY * h;
      end.fX   = end.fX * w;
      end.fY   = end.fY * h;
   } else {
      start.fX = start.fX * bbox.fWidth + bbox.fXMin;
      start.fY = start.fY * bbox.fHeight + bbox.fYMin;
      end.fX   = end.fX * bbox.fWidth + bbox.fXMin;
      end.fY   = end.fY * bbox.fHeight + bbox.fYMin;
   }
 
   //TODO: with a radial fill we'll have to extract the code
   //      below into the separate function/and have additional function
   //      for a radial gradient.
   //Now from pad to pixels:
   start.fX = gPad->XtoPixel(start.fX);
   start.fY = pixelH - gPad->YtoPixel(start.fY);
   end.fX = gPad->XtoPixel(end.fX);
   end.fY = pixelH - gPad->YtoPixel(end.fY);
   const Double_t xMin = gPad->XtoPixel(bbox.fXMin);
   const Double_t xMax = gPad->XtoPixel(bbox.fXMax);
   const Double_t yMin = pixelH - gPad->YtoPixel(bbox.fYMin);
   const Double_t yMax = pixelH - gPad->YtoPixel(bbox.fYMax);
   //
 
   //TODO: check all calculations!
 
   //Get the longest distance from the start point to the bounding box vertices:
   const Double_t maxDistX = TMath::Max(TMath::Abs(start.fX - xMin), TMath::Abs(start.fX - xMax));
   const Double_t maxDistY = TMath::Max(TMath::Abs(start.fY - yMin), TMath::Abs(start.fY - yMax));
 
   const Double_t startEndLength = TMath::Sqrt((end.fX - start.fX) * (end.fX - start.fX) +
                                               (end.fY - start.fY) * (end.fY - start.fY));
   const Double_t h = TMath::Max(TMath::Sqrt(maxDistX * maxDistX + maxDistY * maxDistY),
                                 startEndLength);
 
   //Boxes with a gradients to emulate gradient fill with many colors:
   const Double_t * const colorPositions = grad->GetColorPositions();
   std::vector<Double_t> gradBoxes(grad->GetNumberOfSteps() + 2);
   gradBoxes[0] = start.fY - h;
   for (unsigned i = 1; i <= grad->GetNumberOfSteps(); ++i)
      gradBoxes[i] = startEndLength * colorPositions[i - 1] + start.fY;
 
   gradBoxes[grad->GetNumberOfSteps() + 1] = start.fY + h;
 
   //Rotation angle - gradient's axis:
   Double_t angle = TMath::ACos((startEndLength * (end.fY - start.fY)) /
                                (startEndLength * startEndLength)) * TMath::RadToDeg();
   if (end.fX > start.fX)
      angle *= -1;
 
   glTranslated(start.fX, start.fY, 0.);
   glRotated(angle, 0., 0., 1.);
   glTranslated(-start.fX, -start.fY, 0.);
   //
   const Double_t * const rgba = grad->GetColors();
 
   const unsigned nEdges = gradBoxes.size();
   const unsigned nColors = grad->GetNumberOfSteps();
   const Double_t xLeft = start.fX - h, xRight = start.fX + h;
 
   const TGLEnableGuard alphaGuard(GL_BLEND);
   //TODO?
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   Rgl::DrawBoxWithGradientFill(gradBoxes[0], gradBoxes[1], xLeft, xRight, rgba, rgba);
   Rgl::DrawBoxWithGradientFill(gradBoxes[nEdges - 2], gradBoxes[nEdges - 1], xLeft, xRight,
                           rgba + (nColors - 1) * 4, rgba + (nColors - 1) * 4);
 
   for (unsigned i = 1; i < nEdges - 2; ++i)
      Rgl::DrawBoxWithGradientFill(gradBoxes[i], gradBoxes[i + 1], xLeft,
                                   xRight, rgba + (i - 1) * 4, rgba + i * 4);
 
   RestoreProjectionMatrix();
   RestoreModelviewMatrix();
}
 
////////////////////////////////////////////////////////////////////////////////
 
void TGLPadPainter::DrawTesselation(Int_t n, const Double_t *x, const Double_t *y)
{
   assert(n > 2 && "DrawTesselation, invalid number of points");
   assert(x != nullptr && "DrawTesselation, parameter 'x' is null");
   assert(y != nullptr && "DrawTesselation, parameter 'y' is null");
 
   //Data for a tesselator:
   fVs.resize(n * 3);
 
   for (Int_t i = 0; i < n; ++i) {
      fVs[i * 3]     = x[i];
      fVs[i * 3 + 1] = y[i];
      fVs[i * 3 + 2] = 0.;
   }
 
   //TODO: A very primitive way to tesselate - check what
   //kind of polygons we can really have from TPad/TCanvas.
   GLUtesselator *t = (GLUtesselator *)fTess.GetTess();
   gluBeginPolygon(t);
   gluNextContour(t, (GLenum)GLU_UNKNOWN);
 
   for (Int_t i = 0; i < n; ++i)
      gluTessVertex(t, &fVs[i * 3], &fVs[i * 3]);
 
   gluEndPolygon(t);
}