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

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

#include <TMath.h>

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