[u/mrichter/AliRoot.git] / EVE / Reve / QuadSetGL.cxx

// $Header$

#include "QuadSetGL.h"
#include <Reve/FrameBoxGL.h>

#include <TGLDrawFlags.h>

#include <GL/gl.h>
#include <GL/glu.h>

using namespace Reve;

//______________________________________________________________________
// OldQuadSetGL
//

ClassImp(OldQuadSetGL)

/**************************************************************************/

OldQuadSetGL::OldQuadSetGL() : TGLObject()
{
  // fCached = false; // Disable DL.
}

OldQuadSetGL::~OldQuadSetGL()
{}

/**************************************************************************/

Bool_t OldQuadSetGL::SetModel(TObject* obj)
{
  return SetModelCheckClass(obj, Reve::OldQuadSet::Class());
}

void OldQuadSetGL::SetBBox()
{
  SetAxisAlignedBBox(((OldQuadSet*)fExternalObj)->AssertBBox());
}

/**************************************************************************/

void OldQuadSetGL::DirectDraw(const TGLDrawFlags & ) const
{
  // printf("OldQuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());

  OldQuadSet& Q = * (OldQuadSet*) fExternalObj;

  glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

  glDisable(GL_LIGHTING);
  glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  glEnable(GL_COLOR_MATERIAL);
  glPolygonMode(GL_FRONT, GL_LINE);
  glPolygonMode(GL_BACK,  GL_LINE);
  glDisable(GL_CULL_FACE);

  Float_t c[4]; glGetFloatv(GL_CURRENT_COLOR, c);
  //  UChar_t alpha = (UChar_t)(255*c[3]);

  glBegin(GL_QUADS);
  for(std::vector<Quad>::iterator q=Q.fQuads.begin(); q!=Q.fQuads.end(); ++q) {
    UChar_t* c = (UChar_t*) &q->color;
    //glColor4ub(c[0], c[1], c[2], (c[3]*alpha) >> 8);
    glColor3ub(c[0], c[1], c[2]);
    glVertex3fv(q->vertices);
    glVertex3fv(q->vertices + 3);
    glVertex3fv(q->vertices + 6);
    glVertex3fv(q->vertices + 9);
  }
  glEnd();

  glPopAttrib();
}


/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/

//______________________________________________________________________
// QuadSetGL
//

ClassImp(QuadSetGL)

/**************************************************************************/

  QuadSetGL::QuadSetGL() : TGLObject(), fM(0)
{
  // fCached = false; // Disable DL.
}

QuadSetGL::~QuadSetGL()
{}

/**************************************************************************/

Bool_t QuadSetGL::SetModel(TObject* obj)
{
  Bool_t ok = SetModelCheckClass(obj, Reve::QuadSet::Class());
  fM = ok ? dynamic_cast<Reve::QuadSet*>(obj) : 0;
  return ok;
}

void QuadSetGL::SetBBox()
{
  SetAxisAlignedBBox(fM->AssertBBox());
}

/**************************************************************************/

inline Bool_t QuadSetGL::SetupColor(const QuadSet::QuadBase& q) const
{
  if (fM->fValueIsColor)
  {
    glColor4ubv((UChar_t*) & q.fValue);
    return kTRUE;
  }
  else
  {
    UChar_t c[4];
    Bool_t visible = fM->fPalette->ColorFromValue(q.fValue, fM->fDefaultValue, c);
    if (visible)
      glColor4ubv(c);
    return visible;
  }
}

/**************************************************************************/

void QuadSetGL::DirectDraw(const TGLDrawFlags & flags) const
{
  static const Exc_t eH("QuadSetGL::DirectDraw ");

  // printf("QuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());

  QuadSet& mQ = * fM;

  if (mQ.fFrame != 0)
    FrameBoxGL::Render(mQ.fFrame);

  if (mQ.fPlex.Size() == 0)
    return;
  if ( ! mQ.fValueIsColor && mQ.fPalette == 0)
  {
    mQ.AssertPalette();
  }

  glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
  glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  glEnable(GL_COLOR_MATERIAL);
  glDisable(GL_CULL_FACE);

  if (mQ.fRenderMode == QuadSet::RM_Fill)
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  else if (mQ.fRenderMode == QuadSet::RM_Line)
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  if (mQ.fDisableLigting)  glDisable(GL_LIGHTING);

  if (mQ.fQuadType < QuadSet::QT_Rectangle_End)      RenderQuads(flags);
  else if (mQ.fQuadType < QuadSet::QT_Line_End)      RenderLines(flags);
  else if (mQ.fQuadType < QuadSet::QT_Hexagon_End)   RenderHexagons(flags);

  glPopAttrib();

}


void QuadSetGL::RenderQuads(const TGLDrawFlags &flags) const
{
  static const Exc_t eH("QuadSetGL::RenderQuads ");

  QuadSet& mQ = * fM;

  GLenum primitiveType;
  if (mQ.fRenderMode != QuadSet::RM_Line)
  {
    primitiveType = GL_QUADS;
    if (mQ.fQuadType == QuadSet::QT_FreeQuad)
      glEnable(GL_NORMALIZE);
    else
      glNormal3f(0, 0, 1);
  } else {
    primitiveType = GL_LINE_LOOP;
  }

  VoidCPlex::iterator qi(mQ.fPlex);

  if (flags.SecSelection()) glPushName(0);

  switch (mQ.fQuadType)
  {

    case QuadSet::QT_FreeQuad:
    {
      Float_t e1[3], e2[3], normal[3];
      while (qi.next()) {
	QuadSet::QFreeQuad& q = * (QuadSet::QFreeQuad*) qi();
	if (SetupColor(q))
	{
	  Float_t* p = q.fVertices;
	  e1[0] = p[3] - p[0]; e1[1] = p[4] - p[1]; e1[2] = p[5] - p[2];
	  e2[0] = p[6] - p[0]; e2[1] = p[7] - p[1]; e2[2] = p[8] - p[2];
	  TMath::Cross(e1, e2, normal);
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glNormal3fv(normal);
	  glVertex3fv(p);
	  glVertex3fv(p + 3);
	  glVertex3fv(p + 6);
	  glVertex3fv(p + 9);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXY:
    {
      while (qi.next()) {
	QuadSet::QRect& q = * (QuadSet::QRect*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,        q.fY,        q.fZ);
	  glVertex3f(q.fX + q.fW, q.fY,        q.fZ);
	  glVertex3f(q.fX + q.fW, q.fY + q.fH, q.fZ);
	  glVertex3f(q.fX,        q.fY + q.fH, q.fZ);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXYFixedDim:
    {
      const Float_t& w = mQ.fDefWidth;
      const Float_t& h = mQ.fDefHeight;
      while (qi.next()) {
	QuadSet::QRectFixDim& q = * (QuadSet::QRectFixDim*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,     q.fY,     q.fZ);
	  glVertex3f(q.fX + w, q.fY,     q.fZ);
	  glVertex3f(q.fX + w, q.fY + h, q.fZ);
	  glVertex3f(q.fX,     q.fY + h, q.fZ);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXYFixedZ:
    {
      const Float_t& z = mQ.fDefCoord;
      while (qi.next()) {
	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,        q.fY,        z);
	  glVertex3f(q.fX + q.fW, q.fY,        z);
	  glVertex3f(q.fX + q.fW, q.fY + q.fH, z);
	  glVertex3f(q.fX,        q.fY + q.fH, z);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXZFixedY:
    {
      const Float_t& z = mQ.fDefCoord;
      while (qi.next()) {
	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,        z, q.fY);
	  glVertex3f(q.fX + q.fW, z, q.fY);
	  glVertex3f(q.fX + q.fW, z, q.fY + q.fH);
	  glVertex3f(q.fX,        z, q.fY + q.fH);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXYFixedDimZ:
    {
      const Float_t& z = mQ.fDefCoord;
      const Float_t& w = mQ.fDefWidth;
      const Float_t& h = mQ.fDefHeight;
      while (qi.next()) {
	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,     q.fY,     z);
	  glVertex3f(q.fX + w, q.fY,     z);
	  glVertex3f(q.fX + w, q.fY + h, z);
	  glVertex3f(q.fX,     q.fY + h, z);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXZFixedDimY:
    {
      const Float_t& z = mQ.fDefCoord;
      const Float_t& w = mQ.fDefWidth;
      const Float_t& h = mQ.fDefHeight;
      while (qi.next()) {
	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fX,     z, q.fY);
	  glVertex3f(q.fX + w, z, q.fY);
	  glVertex3f(q.fX + w, z, q.fY + h);
	  glVertex3f(q.fX,     z, q.fY + h);
	  glEnd();
	}
      }
      break;
    }

    default:
      throw(eH + "unsupported quad-type.");

  } // end switch quad-type

  if (flags.SecSelection()) glPopName();
}


void QuadSetGL::RenderLines(const TGLDrawFlags &flags) const
{
  static const Exc_t eH("QuadSetGL::RenderLines ");

  QuadSet& mQ = * fM;

  VoidCPlex::iterator qi(mQ.fPlex);

  if (flags.SecSelection()) glPushName(0);

  switch (mQ.fQuadType)
  {

    case QuadSet::QT_LineXYFixedZ:
    {
      const Float_t& z = mQ.fDefCoord;
      while (qi.next()) {
	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(GL_LINES);
	  glVertex3f(q.fX,         q.fY,         z);
	  glVertex3f(q.fX + q.fDx, q.fY + q.fDy, z);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_LineXZFixedY:
    {
      const Float_t& z = mQ.fDefCoord;
      while (qi.next()) {
	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(GL_LINES);
	  glVertex3f(q.fX,         z, q.fY);
	  glVertex3f(q.fX + q.fDx, z, q.fY + q.fDy);
	  glEnd();
	}
      }
      break;
    }

    default:
      throw(eH + "unsupported quad-type.");

  }

  if (flags.SecSelection()) glPopName();
}

void QuadSetGL::RenderHexagons(const TGLDrawFlags &flags) const
{
  static const Exc_t eH("QuadSetGL::RenderHexagons ");

  const Float_t sqr3hf = 0.5*TMath::Sqrt(3);

  QuadSet& mQ = * fM;

  GLenum primitveType = (mQ.fRenderMode != QuadSet::RM_Line) ?
    GL_POLYGON : GL_LINE_LOOP;

  glNormal3f(0, 0, 1);

  VoidCPlex::iterator qi(mQ.fPlex);

  if (flags.SecSelection()) glPushName(0);

  switch (mQ.fQuadType)
  {

    case QuadSet::QT_HexagonXY:
    {
      while (qi.next()) {
	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	if (SetupColor(q))
	{
	  const Float_t rh = q.fR * 0.5;
	  const Float_t rs = q.fR * sqr3hf;
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitveType);
	  glVertex3f( q.fR + q.fX,       q.fY, q.fZ);
	  glVertex3f(   rh + q.fX,  rs + q.fY, q.fZ);
	  glVertex3f(  -rh + q.fX,  rs + q.fY, q.fZ);
	  glVertex3f(-q.fR + q.fX,       q.fY, q.fZ);
	  glVertex3f(  -rh + q.fX, -rs + q.fY, q.fZ);
	  glVertex3f(   rh + q.fX, -rs + q.fY, q.fZ);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_HexagonYX:
    {
      while (qi.next()) {
	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	if (SetupColor(q))
	{
	  const Float_t rh = q.fR * 0.5;
	  const Float_t rs = q.fR * sqr3hf;
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitveType);
	  glVertex3f( rs + q.fX,    rh + q.fY, q.fZ);
	  glVertex3f(      q.fX,  q.fR + q.fY, q.fZ);
	  glVertex3f(-rs + q.fX,    rh + q.fY, q.fZ);
	  glVertex3f(-rs + q.fX,   -rh + q.fY, q.fZ);
	  glVertex3f(      q.fX, -q.fR + q.fY, q.fZ);
	  glVertex3f( rs + q.fX,   -rh + q.fY, q.fZ);
	  glEnd();
	}
      }
      break;
    }

    default:
      throw(eH + "unsupported quad-type.");

  } // end switch quad-type

  if (flags.SecSelection()) glPopName();
}

/**************************************************************************/
/**************************************************************************/

//______________________________________________________________________________
void QuadSetGL::ProcessSelection(UInt_t* ptr, TGLViewer*, TGLScene*)
{
   // Processes secondary selection from TGLViewer.
   // Calls TPointSet3D::PointSelected(Int_t) with index of selected
   // point as an argument.

   if (ptr[0] < 2) return;
   fM->QuadSelected(ptr[4]);
}
Commit	Line	Data
5a5a1232	1	// $Header$
	2
	3	#include "QuadSetGL.h"
8be1b0cc	4	#include <Reve/FrameBoxGL.h>
5a5a1232	5
	6	#include <TGLDrawFlags.h>
	7
	8	#include <GL/gl.h>
	9	#include <GL/glu.h>
	10
	11	using namespace Reve;
	12
	13	//______________________________________________________________________
3aa97c5d	14	// OldQuadSetGL
5a5a1232	15	//
5a5a1232	16
3aa97c5d	17	ClassImp(OldQuadSetGL)
5a5a1232	18
	19	/**************************************************************************/
	20
3aa97c5d	21	OldQuadSetGL::OldQuadSetGL() : TGLObject()
5a5a1232	22	{
	23	// fCached = false; // Disable DL.
	24	}
	25
3aa97c5d	26	OldQuadSetGL::~OldQuadSetGL()
5a5a1232	27	{}
	28
	29	/**************************************************************************/
	30
3aa97c5d	31	Bool_t OldQuadSetGL::SetModel(TObject* obj)
5a5a1232	32	{
3aa97c5d	33	return SetModelCheckClass(obj, Reve::OldQuadSet::Class());
5a5a1232	34	}
5a5a1232	35
3aa97c5d	36	void OldQuadSetGL::SetBBox()
5a5a1232	37	{
3aa97c5d	38	SetAxisAlignedBBox(((OldQuadSet*)fExternalObj)->AssertBBox());
5a5a1232	39	}
	40
	41	/**************************************************************************/
	42
3aa97c5d	43	void OldQuadSetGL::DirectDraw(const TGLDrawFlags & ) const
5a5a1232	44	{
3aa97c5d	45	// printf("OldQuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());
5a5a1232	46
3aa97c5d	47	OldQuadSet& Q = * (OldQuadSet*) fExternalObj;
5a5a1232	48
	49	glPushAttrib(GL_ENABLE_BIT \| GL_POLYGON_BIT);
	50
	51	glDisable(GL_LIGHTING);
	52	glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
	53	glEnable(GL_COLOR_MATERIAL);
	54	glPolygonMode(GL_FRONT, GL_LINE);
	55	glPolygonMode(GL_BACK, GL_LINE);
	56	glDisable(GL_CULL_FACE);
	57
	58	Float_t c[4]; glGetFloatv(GL_CURRENT_COLOR, c);
	59	// UChar_t alpha = (UChar_t)(255*c[3]);
	60
	61	glBegin(GL_QUADS);
	62	for(std::vector<Quad>::iterator q=Q.fQuads.begin(); q!=Q.fQuads.end(); ++q) {
	63	UChar_t* c = (UChar_t*) &q->color;
	64	//glColor4ub(c[0], c[1], c[2], (c[3]*alpha) >> 8);
	65	glColor3ub(c[0], c[1], c[2]);
	66	glVertex3fv(q->vertices);
	67	glVertex3fv(q->vertices + 3);
	68	glVertex3fv(q->vertices + 6);
	69	glVertex3fv(q->vertices + 9);
	70	}
	71	glEnd();
	72
	73	glPopAttrib();
	74	}
8be1b0cc	75
	76
	77	/**************************************************************************/
	78	/**************************************************************************/
	79	/**************************************************************************/
	80	/**************************************************************************/
	81
	82	//______________________________________________________________________
	83	// QuadSetGL
	84	//
	85
	86	ClassImp(QuadSetGL)
	87
	88	/**************************************************************************/
	89
	90	QuadSetGL::QuadSetGL() : TGLObject(), fM(0)
	91	{
	92	// fCached = false; // Disable DL.
	93	}
	94
	95	QuadSetGL::~QuadSetGL()
	96	{}
	97
	98	/**************************************************************************/
	99
	100	Bool_t QuadSetGL::SetModel(TObject* obj)
	101	{
	102	Bool_t ok = SetModelCheckClass(obj, Reve::QuadSet::Class());
	103	fM = ok ? dynamic_cast<Reve::QuadSet*>(obj) : 0;
	104	return ok;
	105	}
	106
	107	void QuadSetGL::SetBBox()
	108	{
	109	SetAxisAlignedBBox(fM->AssertBBox());
	110	}
	111
	112	/**************************************************************************/
	113
	114	inline Bool_t QuadSetGL::SetupColor(const QuadSet::QuadBase& q) const
	115	{
	116	if (fM->fValueIsColor)
	117	{
	118	glColor4ubv((UChar_t*) & q.fValue);
975a1f61	119	return kTRUE;
8be1b0cc	120	}
	121	else
	122	{
975a1f61	123	UChar_t c[4];
	124	Bool_t visible = fM->fPalette->ColorFromValue(q.fValue, fM->fDefaultValue, c);
	125	if (visible)
	126	glColor4ubv(c);
	127	return visible;
8be1b0cc	128	}
8be1b0cc	129	}
	130
	131	/**************************************************************************/
	132
	133	void QuadSetGL::DirectDraw(const TGLDrawFlags & flags) const
	134	{
	135	static const Exc_t eH("QuadSetGL::DirectDraw ");
	136
	137	// printf("QuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());
	138
	139	QuadSet& mQ = * fM;
44eb96d2	140
	141	if (mQ.fFrame != 0)
	142	FrameBoxGL::Render(mQ.fFrame);
	143
8be1b0cc	144	if (mQ.fPlex.Size() == 0)
	145	return;
	146	if ( ! mQ.fValueIsColor && mQ.fPalette == 0)
	147	{
20358789	148	mQ.AssertPalette();
8be1b0cc	149	}
8be1b0cc	150
8be1b0cc	151	glPushAttrib(GL_ENABLE_BIT \| GL_POLYGON_BIT);
	152	glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
	153	glEnable(GL_COLOR_MATERIAL);
	154	glDisable(GL_CULL_FACE);
	155
	156	if (mQ.fRenderMode == QuadSet::RM_Fill)
8be1b0cc	157	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
8be1b0cc	158	else if (mQ.fRenderMode == QuadSet::RM_Line)
8be1b0cc	159	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
8be1b0cc	160
20358789	161	if (mQ.fDisableLigting) glDisable(GL_LIGHTING);
20358789	162
96c51586	163	if (mQ.fQuadType < QuadSet::QT_Rectangle_End) RenderQuads(flags);
	164	else if (mQ.fQuadType < QuadSet::QT_Line_End) RenderLines(flags);
	165	else if (mQ.fQuadType < QuadSet::QT_Hexagon_End) RenderHexagons(flags);
20358789	166
8be1b0cc	167	glPopAttrib();
	168
	169	}
	170
	171
1545977c	172	void QuadSetGL::RenderQuads(const TGLDrawFlags &flags) const
8be1b0cc	173	{
	174	static const Exc_t eH("QuadSetGL::RenderQuads ");
	175
	176	QuadSet& mQ = * fM;
	177
1545977c	178	GLenum primitiveType;
8be1b0cc	179	if (mQ.fRenderMode != QuadSet::RM_Line)
8be1b0cc	180	{
1545977c	181	primitiveType = GL_QUADS;
8be1b0cc	182	if (mQ.fQuadType == QuadSet::QT_FreeQuad)
	183	glEnable(GL_NORMALIZE);
	184	else
	185	glNormal3f(0, 0, 1);
1545977c	186	} else {
	187	primitiveType = GL_LINE_LOOP;
	188	}
8be1b0cc	189
1545977c	190	VoidCPlex::iterator qi(mQ.fPlex);
8be1b0cc	191
1545977c	192	if (flags.SecSelection()) glPushName(0);
8be1b0cc	193
1545977c	194	switch (mQ.fQuadType)
8be1b0cc	195	{
8be1b0cc	196
1545977c	197	case QuadSet::QT_FreeQuad:
8be1b0cc	198	{
1545977c	199	Float_t e1[3], e2[3], normal[3];
	200	while (qi.next()) {
	201	QuadSet::QFreeQuad& q = * (QuadSet::QFreeQuad*) qi();
	202	if (SetupColor(q))
	203	{
	204	Float_t* p = q.fVertices;
	205	e1[0] = p[3] - p[0]; e1[1] = p[4] - p[1]; e1[2] = p[5] - p[2];
	206	e2[0] = p[6] - p[0]; e2[1] = p[7] - p[1]; e2[2] = p[8] - p[2];
	207	TMath::Cross(e1, e2, normal);
	208	if (flags.SecSelection()) glLoadName(qi.index());
	209	glBegin(primitiveType);
	210	glNormal3fv(normal);
	211	glVertex3fv(p);
	212	glVertex3fv(p + 3);
	213	glVertex3fv(p + 6);
	214	glVertex3fv(p + 9);
	215	glEnd();
8be1b0cc	216	}
ca462fa9	217	}
1545977c	218	break;
1545977c	219	}
8be1b0cc	220
1545977c	221	case QuadSet::QT_RectangleXY:
	222	{
	223	while (qi.next()) {
	224	QuadSet::QRect& q = * (QuadSet::QRect*) qi();
	225	if (SetupColor(q))
	226	{
	227	if (flags.SecSelection()) glLoadName(qi.index());
	228	glBegin(primitiveType);
	229	glVertex3f(q.fX, q.fY, q.fZ);
	230	glVertex3f(q.fX + q.fW, q.fY, q.fZ);
	231	glVertex3f(q.fX + q.fW, q.fY + q.fH, q.fZ);
	232	glVertex3f(q.fX, q.fY + q.fH, q.fZ);
	233	glEnd();
8be1b0cc	234	}
ca462fa9	235	}
1545977c	236	break;
1545977c	237	}
8be1b0cc	238
1545977c	239	case QuadSet::QT_RectangleXYFixedDim:
	240	{
	241	const Float_t& w = mQ.fDefWidth;
	242	const Float_t& h = mQ.fDefHeight;
	243	while (qi.next()) {
	244	QuadSet::QRectFixDim& q = * (QuadSet::QRectFixDim*) qi();
	245	if (SetupColor(q))
	246	{
	247	if (flags.SecSelection()) glLoadName(qi.index());
	248	glBegin(primitiveType);
	249	glVertex3f(q.fX, q.fY, q.fZ);
	250	glVertex3f(q.fX + w, q.fY, q.fZ);
	251	glVertex3f(q.fX + w, q.fY + h, q.fZ);
	252	glVertex3f(q.fX, q.fY + h, q.fZ);
	253	glEnd();
8be1b0cc	254	}
ca462fa9	255	}
1545977c	256	break;
1545977c	257	}
8be1b0cc	258
1545977c	259	case QuadSet::QT_RectangleXYFixedZ:
	260	{
	261	const Float_t& z = mQ.fDefCoord;
	262	while (qi.next()) {
	263	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	264	if (SetupColor(q))
	265	{
	266	if (flags.SecSelection()) glLoadName(qi.index());
	267	glBegin(primitiveType);
	268	glVertex3f(q.fX, q.fY, z);
	269	glVertex3f(q.fX + q.fW, q.fY, z);
	270	glVertex3f(q.fX + q.fW, q.fY + q.fH, z);
	271	glVertex3f(q.fX, q.fY + q.fH, z);
	272	glEnd();
8be1b0cc	273	}
ca462fa9	274	}
1545977c	275	break;
1545977c	276	}
8be1b0cc	277
1545977c	278	case QuadSet::QT_RectangleXZFixedY:
	279	{
	280	const Float_t& z = mQ.fDefCoord;
	281	while (qi.next()) {
	282	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	283	if (SetupColor(q))
	284	{
	285	if (flags.SecSelection()) glLoadName(qi.index());
	286	glBegin(primitiveType);
	287	glVertex3f(q.fX, z, q.fY);
	288	glVertex3f(q.fX + q.fW, z, q.fY);
	289	glVertex3f(q.fX + q.fW, z, q.fY + q.fH);
	290	glVertex3f(q.fX, z, q.fY + q.fH);
	291	glEnd();
8be1b0cc	292	}
ca462fa9	293	}
1545977c	294	break;
1545977c	295	}
8be1b0cc	296
1545977c	297	case QuadSet::QT_RectangleXYFixedDimZ:
	298	{
	299	const Float_t& z = mQ.fDefCoord;
	300	const Float_t& w = mQ.fDefWidth;
	301	const Float_t& h = mQ.fDefHeight;
	302	while (qi.next()) {
	303	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	304	if (SetupColor(q))
	305	{
	306	if (flags.SecSelection()) glLoadName(qi.index());
	307	glBegin(primitiveType);
	308	glVertex3f(q.fX, q.fY, z);
	309	glVertex3f(q.fX + w, q.fY, z);
	310	glVertex3f(q.fX + w, q.fY + h, z);
	311	glVertex3f(q.fX, q.fY + h, z);
	312	glEnd();
8be1b0cc	313	}
ca462fa9	314	}
1545977c	315	break;
1545977c	316	}
8be1b0cc	317
1545977c	318	case QuadSet::QT_RectangleXZFixedDimY:
	319	{
	320	const Float_t& z = mQ.fDefCoord;
	321	const Float_t& w = mQ.fDefWidth;
	322	const Float_t& h = mQ.fDefHeight;
	323	while (qi.next()) {
	324	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	325	if (SetupColor(q))
	326	{
	327	if (flags.SecSelection()) glLoadName(qi.index());
	328	glBegin(primitiveType);
	329	glVertex3f(q.fX, z, q.fY);
	330	glVertex3f(q.fX + w, z, q.fY);
	331	glVertex3f(q.fX + w, z, q.fY + h);
	332	glVertex3f(q.fX, z, q.fY + h);
	333	glEnd();
8be1b0cc	334	}
ca462fa9	335	}
1545977c	336	break;
1545977c	337	}
8be1b0cc	338
1545977c	339	default:
1545977c	340	throw(eH + "unsupported quad-type.");
8be1b0cc	341
1545977c	342	} // end switch quad-type
8be1b0cc	343
1545977c	344	if (flags.SecSelection()) glPopName();
8be1b0cc	345	}
	346
	347
1545977c	348	void QuadSetGL::RenderLines(const TGLDrawFlags &flags) const
8be1b0cc	349	{
	350	static const Exc_t eH("QuadSetGL::RenderLines ");
	351
	352	QuadSet& mQ = * fM;
	353
ca462fa9	354	VoidCPlex::iterator qi(mQ.fPlex);
ca462fa9	355
1545977c	356	if (flags.SecSelection()) glPushName(0);
ca462fa9	357
ca462fa9	358	switch (mQ.fQuadType)
8be1b0cc	359	{
8be1b0cc	360
ca462fa9	361	case QuadSet::QT_LineXYFixedZ:
8be1b0cc	362	{
ca462fa9	363	const Float_t& z = mQ.fDefCoord;
	364	while (qi.next()) {
	365	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	366	if (SetupColor(q))
	367	{
1545977c	368	if (flags.SecSelection()) glLoadName(qi.index());
1545977c	369	glBegin(GL_LINES);
ca462fa9	370	glVertex3f(q.fX, q.fY, z);
ca462fa9	371	glVertex3f(q.fX + q.fDx, q.fY + q.fDy, z);
1545977c	372	glEnd();
8be1b0cc	373	}
8be1b0cc	374	}
ca462fa9	375	break;
ca462fa9	376	}
8be1b0cc	377
ca462fa9	378	case QuadSet::QT_LineXZFixedY:
	379	{
	380	const Float_t& z = mQ.fDefCoord;
	381	while (qi.next()) {
	382	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	383	if (SetupColor(q))
	384	{
1545977c	385	if (flags.SecSelection()) glLoadName(qi.index());
1545977c	386	glBegin(GL_LINES);
ca462fa9	387	glVertex3f(q.fX, z, q.fY);
ca462fa9	388	glVertex3f(q.fX + q.fDx, z, q.fY + q.fDy);
1545977c	389	glEnd();
8be1b0cc	390	}
8be1b0cc	391	}
ca462fa9	392	break;
ca462fa9	393	}
8be1b0cc	394
ca462fa9	395	default:
ca462fa9	396	throw(eH + "unsupported quad-type.");
8be1b0cc	397
8be1b0cc	398	}
ca462fa9	399
1545977c	400	if (flags.SecSelection()) glPopName();
8be1b0cc	401	}
96c51586	402
1545977c	403	void QuadSetGL::RenderHexagons(const TGLDrawFlags &flags) const
96c51586	404	{
	405	static const Exc_t eH("QuadSetGL::RenderHexagons ");
	406
	407	const Float_t sqr3hf = 0.5*TMath::Sqrt(3);
	408
	409	QuadSet& mQ = * fM;
	410
ca462fa9	411	GLenum primitveType = (mQ.fRenderMode != QuadSet::RM_Line) ?
ca462fa9	412	GL_POLYGON : GL_LINE_LOOP;
96c51586	413
ca462fa9	414	glNormal3f(0, 0, 1);
96c51586	415
ca462fa9	416	VoidCPlex::iterator qi(mQ.fPlex);
96c51586	417
1545977c	418	if (flags.SecSelection()) glPushName(0);
1545977c	419
ca462fa9	420	switch (mQ.fQuadType)
96c51586	421	{
96c51586	422
ca462fa9	423	case QuadSet::QT_HexagonXY:
96c51586	424	{
ca462fa9	425	while (qi.next()) {
	426	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	427	if (SetupColor(q))
96c51586	428	{
ca462fa9	429	const Float_t rh = q.fR * 0.5;
ca462fa9	430	const Float_t rs = q.fR * sqr3hf;
1545977c	431	if (flags.SecSelection()) glLoadName(qi.index());
ca462fa9	432	glBegin(primitveType);
	433	glVertex3f( q.fR + q.fX, q.fY, q.fZ);
	434	glVertex3f( rh + q.fX, rs + q.fY, q.fZ);
	435	glVertex3f( -rh + q.fX, rs + q.fY, q.fZ);
	436	glVertex3f(-q.fR + q.fX, q.fY, q.fZ);
	437	glVertex3f( -rh + q.fX, -rs + q.fY, q.fZ);
	438	glVertex3f( rh + q.fX, -rs + q.fY, q.fZ);
	439	glEnd();
96c51586	440	}
ca462fa9	441	}
	442	break;
	443	}
96c51586	444
ca462fa9	445	case QuadSet::QT_HexagonYX:
	446	{
	447	while (qi.next()) {
	448	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	449	if (SetupColor(q))
96c51586	450	{
ca462fa9	451	const Float_t rh = q.fR * 0.5;
ca462fa9	452	const Float_t rs = q.fR * sqr3hf;
1545977c	453	if (flags.SecSelection()) glLoadName(qi.index());
ca462fa9	454	glBegin(primitveType);
	455	glVertex3f( rs + q.fX, rh + q.fY, q.fZ);
	456	glVertex3f( q.fX, q.fR + q.fY, q.fZ);
	457	glVertex3f(-rs + q.fX, rh + q.fY, q.fZ);
	458	glVertex3f(-rs + q.fX, -rh + q.fY, q.fZ);
	459	glVertex3f( q.fX, -q.fR + q.fY, q.fZ);
	460	glVertex3f( rs + q.fX, -rh + q.fY, q.fZ);
	461	glEnd();
96c51586	462	}
ca462fa9	463	}
	464	break;
	465	}
96c51586	466
ca462fa9	467	default:
ca462fa9	468	throw(eH + "unsupported quad-type.");
96c51586	469
ca462fa9	470	} // end switch quad-type
96c51586	471
1545977c	472	if (flags.SecSelection()) glPopName();
	473	}
	474
	475	/**************************************************************************/
	476	/**************************************************************************/
	477
	478	//______________________________________________________________________________
	479	void QuadSetGL::ProcessSelection(UInt_t* ptr, TGLViewer, TGLScene)
	480	{
	481	// Processes secondary selection from TGLViewer.
	482	// Calls TPointSet3D::PointSelected(Int_t) with index of selected
	483	// point as an argument.
	484
	485	if (ptr[0] < 2) return;
	486	fM->QuadSelected(ptr[4]);
96c51586	487	}