[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.fA,        q.fB,        q.fC);
	  glVertex3f(q.fA + q.fW, q.fB,        q.fC);
	  glVertex3f(q.fA + q.fW, q.fB + q.fH, q.fC);
	  glVertex3f(q.fA,        q.fB + q.fH, q.fC);
	  glEnd();
	}
      }
      break;
    }

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

    case QuadSet::QT_RectangleYZ:
    {
      while (qi.next()) {
	QuadSet::QRect& q = * (QuadSet::QRect*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(q.fC, q.fA,        q.fB);
	  glVertex3f(q.fC, q.fA + q.fW, q.fB);
	  glVertex3f(q.fC, q.fA + q.fW, q.fB + q.fH);
	  glVertex3f(q.fC, q.fA,        q.fB + q.fH);
	  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.fA,     q.fB,     q.fC);
	  glVertex3f(q.fA + w, q.fB,     q.fC);
	  glVertex3f(q.fA + w, q.fB + h, q.fC);
	  glVertex3f(q.fA,     q.fB + h, q.fC);
	  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.fA,        q.fB,        z);
	  glVertex3f(q.fA + q.fW, q.fB,        z);
	  glVertex3f(q.fA + q.fW, q.fB + q.fH, z);
	  glVertex3f(q.fA,        q.fB + q.fH, z);
	  glEnd();
	}
      }
      break;
    }

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

    case QuadSet::QT_RectangleYZFixedX:
    {
      const Float_t& x = mQ.fDefCoord;
      while (qi.next()) {
	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	if (SetupColor(q))
	{
	  if (flags.SecSelection()) glLoadName(qi.index());
	  glBegin(primitiveType);
	  glVertex3f(x, q.fA,        q.fB);
	  glVertex3f(x, q.fA + q.fW, q.fB);
	  glVertex3f(x, q.fA + q.fW, q.fB + q.fH);
	  glVertex3f(x, q.fA,        q.fB + 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.fA,     q.fB,     z);
	  glVertex3f(q.fA + w, q.fB,     z);
	  glVertex3f(q.fA + w, q.fB + h, z);
	  glVertex3f(q.fA,     q.fB + h, z);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleXZFixedDimY:
    {
      const Float_t& y = 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.fA,     y, q.fB);
	  glVertex3f(q.fA + w, y, q.fB);
	  glVertex3f(q.fA + w, y, q.fB + h);
	  glVertex3f(q.fA,     y, q.fB + h);
	  glEnd();
	}
      }
      break;
    }

    case QuadSet::QT_RectangleYZFixedDimX:
    {
      const Float_t& x = 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(x, q.fA,     q.fB);
	  glVertex3f(x, q.fA + w, q.fB);
	  glVertex3f(x, q.fA + w, q.fB + h);
	  glVertex3f(x, q.fA,     q.fB + 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.fA,         q.fB,         z);
	  glVertex3f(q.fA + q.fDx, q.fB + 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.fA,         z, q.fB);
	  glVertex3f(q.fA + q.fDx, z, q.fB + 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.fA,       q.fB, q.fC);
	  glVertex3f(   rh + q.fA,  rs + q.fB, q.fC);
	  glVertex3f(  -rh + q.fA,  rs + q.fB, q.fC);
	  glVertex3f(-q.fR + q.fA,       q.fB, q.fC);
	  glVertex3f(  -rh + q.fA, -rs + q.fB, q.fC);
	  glVertex3f(   rh + q.fA, -rs + q.fB, q.fC);
	  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.fA,    rh + q.fB, q.fC);
	  glVertex3f(      q.fA,  q.fR + q.fB, q.fC);
	  glVertex3f(-rs + q.fA,    rh + q.fB, q.fC);
	  glVertex3f(-rs + q.fA,   -rh + q.fB, q.fC);
	  glVertex3f(      q.fA, -q.fR + q.fB, q.fC);
	  glVertex3f( rs + q.fA,   -rh + q.fB, q.fC);
	  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
89083271	107	QuadSetGL::QuadSetGL() : TGLObject(), fM(0)
8be1b0cc	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);
253a61b0	246	glVertex3f(q.fA, q.fB, q.fC);
	247	glVertex3f(q.fA + q.fW, q.fB, q.fC);
	248	glVertex3f(q.fA + q.fW, q.fB + q.fH, q.fC);
	249	glVertex3f(q.fA, q.fB + q.fH, q.fC);
	250	glEnd();
	251	}
	252	}
	253	break;
	254	}
	255
	256	case QuadSet::QT_RectangleXZ:
	257	{
	258	while (qi.next()) {
	259	QuadSet::QRect& q = * (QuadSet::QRect*) qi();
	260	if (SetupColor(q))
	261	{
	262	if (flags.SecSelection()) glLoadName(qi.index());
	263	glBegin(primitiveType);
	264	glVertex3f(q.fA, q.fC, q.fB);
	265	glVertex3f(q.fA + q.fW, q.fC, q.fB);
	266	glVertex3f(q.fA + q.fW, q.fC, q.fB + q.fH);
	267	glVertex3f(q.fA, q.fC, q.fB + q.fH);
	268	glEnd();
	269	}
	270	}
	271	break;
	272	}
	273
	274	case QuadSet::QT_RectangleYZ:
	275	{
	276	while (qi.next()) {
	277	QuadSet::QRect& q = * (QuadSet::QRect*) qi();
	278	if (SetupColor(q))
	279	{
	280	if (flags.SecSelection()) glLoadName(qi.index());
	281	glBegin(primitiveType);
	282	glVertex3f(q.fC, q.fA, q.fB);
	283	glVertex3f(q.fC, q.fA + q.fW, q.fB);
	284	glVertex3f(q.fC, q.fA + q.fW, q.fB + q.fH);
	285	glVertex3f(q.fC, q.fA, q.fB + q.fH);
1545977c	286	glEnd();
8be1b0cc	287	}
ca462fa9	288	}
1545977c	289	break;
1545977c	290	}
8be1b0cc	291
1545977c	292	case QuadSet::QT_RectangleXYFixedDim:
	293	{
	294	const Float_t& w = mQ.fDefWidth;
	295	const Float_t& h = mQ.fDefHeight;
	296	while (qi.next()) {
	297	QuadSet::QRectFixDim& q = * (QuadSet::QRectFixDim*) qi();
	298	if (SetupColor(q))
	299	{
	300	if (flags.SecSelection()) glLoadName(qi.index());
	301	glBegin(primitiveType);
253a61b0	302	glVertex3f(q.fA, q.fB, q.fC);
	303	glVertex3f(q.fA + w, q.fB, q.fC);
	304	glVertex3f(q.fA + w, q.fB + h, q.fC);
	305	glVertex3f(q.fA, q.fB + h, q.fC);
1545977c	306	glEnd();
8be1b0cc	307	}
ca462fa9	308	}
1545977c	309	break;
1545977c	310	}
8be1b0cc	311
1545977c	312	case QuadSet::QT_RectangleXYFixedZ:
	313	{
	314	const Float_t& z = mQ.fDefCoord;
	315	while (qi.next()) {
	316	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	317	if (SetupColor(q))
	318	{
	319	if (flags.SecSelection()) glLoadName(qi.index());
	320	glBegin(primitiveType);
253a61b0	321	glVertex3f(q.fA, q.fB, z);
	322	glVertex3f(q.fA + q.fW, q.fB, z);
	323	glVertex3f(q.fA + q.fW, q.fB + q.fH, z);
	324	glVertex3f(q.fA, q.fB + q.fH, z);
1545977c	325	glEnd();
8be1b0cc	326	}
ca462fa9	327	}
1545977c	328	break;
1545977c	329	}
8be1b0cc	330
1545977c	331	case QuadSet::QT_RectangleXZFixedY:
1545977c	332	{
253a61b0	333	const Float_t& y = mQ.fDefCoord;
	334	while (qi.next()) {
	335	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	336	if (SetupColor(q))
	337	{
	338	if (flags.SecSelection()) glLoadName(qi.index());
	339	glBegin(primitiveType);
	340	glVertex3f(q.fA, y, q.fB);
	341	glVertex3f(q.fA + q.fW, y, q.fB);
	342	glVertex3f(q.fA + q.fW, y, q.fB + q.fH);
	343	glVertex3f(q.fA, y, q.fB + q.fH);
	344	glEnd();
	345	}
	346	}
	347	break;
	348	}
	349
	350	case QuadSet::QT_RectangleYZFixedX:
	351	{
	352	const Float_t& x = mQ.fDefCoord;
1545977c	353	while (qi.next()) {
	354	QuadSet::QRectFixC& q = * (QuadSet::QRectFixC*) qi();
	355	if (SetupColor(q))
	356	{
	357	if (flags.SecSelection()) glLoadName(qi.index());
	358	glBegin(primitiveType);
253a61b0	359	glVertex3f(x, q.fA, q.fB);
	360	glVertex3f(x, q.fA + q.fW, q.fB);
	361	glVertex3f(x, q.fA + q.fW, q.fB + q.fH);
	362	glVertex3f(x, q.fA, q.fB + q.fH);
1545977c	363	glEnd();
8be1b0cc	364	}
ca462fa9	365	}
1545977c	366	break;
1545977c	367	}
8be1b0cc	368
1545977c	369	case QuadSet::QT_RectangleXYFixedDimZ:
	370	{
	371	const Float_t& z = mQ.fDefCoord;
	372	const Float_t& w = mQ.fDefWidth;
	373	const Float_t& h = mQ.fDefHeight;
	374	while (qi.next()) {
	375	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	376	if (SetupColor(q))
	377	{
	378	if (flags.SecSelection()) glLoadName(qi.index());
	379	glBegin(primitiveType);
253a61b0	380	glVertex3f(q.fA, q.fB, z);
	381	glVertex3f(q.fA + w, q.fB, z);
	382	glVertex3f(q.fA + w, q.fB + h, z);
	383	glVertex3f(q.fA, q.fB + h, z);
1545977c	384	glEnd();
8be1b0cc	385	}
ca462fa9	386	}
1545977c	387	break;
1545977c	388	}
8be1b0cc	389
1545977c	390	case QuadSet::QT_RectangleXZFixedDimY:
1545977c	391	{
253a61b0	392	const Float_t& y = mQ.fDefCoord;
	393	const Float_t& w = mQ.fDefWidth;
	394	const Float_t& h = mQ.fDefHeight;
	395	while (qi.next()) {
	396	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	397	if (SetupColor(q))
	398	{
	399	if (flags.SecSelection()) glLoadName(qi.index());
	400	glBegin(primitiveType);
	401	glVertex3f(q.fA, y, q.fB);
	402	glVertex3f(q.fA + w, y, q.fB);
	403	glVertex3f(q.fA + w, y, q.fB + h);
	404	glVertex3f(q.fA, y, q.fB + h);
	405	glEnd();
	406	}
	407	}
	408	break;
	409	}
	410
	411	case QuadSet::QT_RectangleYZFixedDimX:
	412	{
	413	const Float_t& x = mQ.fDefCoord;
1545977c	414	const Float_t& w = mQ.fDefWidth;
	415	const Float_t& h = mQ.fDefHeight;
	416	while (qi.next()) {
	417	QuadSet::QRectFixDimC& q = * (QuadSet::QRectFixDimC*) qi();
	418	if (SetupColor(q))
	419	{
	420	if (flags.SecSelection()) glLoadName(qi.index());
	421	glBegin(primitiveType);
253a61b0	422	glVertex3f(x, q.fA, q.fB);
	423	glVertex3f(x, q.fA + w, q.fB);
	424	glVertex3f(x, q.fA + w, q.fB + h);
	425	glVertex3f(x, q.fA, q.fB + h);
1545977c	426	glEnd();
8be1b0cc	427	}
ca462fa9	428	}
1545977c	429	break;
1545977c	430	}
8be1b0cc	431
1545977c	432	default:
1545977c	433	throw(eH + "unsupported quad-type.");
8be1b0cc	434
1545977c	435	} // end switch quad-type
8be1b0cc	436
1545977c	437	if (flags.SecSelection()) glPopName();
8be1b0cc	438	}
	439
	440
1545977c	441	void QuadSetGL::RenderLines(const TGLDrawFlags &flags) const
8be1b0cc	442	{
	443	static const Exc_t eH("QuadSetGL::RenderLines ");
	444
	445	QuadSet& mQ = * fM;
	446
ca462fa9	447	VoidCPlex::iterator qi(mQ.fPlex);
ca462fa9	448
1545977c	449	if (flags.SecSelection()) glPushName(0);
ca462fa9	450
ca462fa9	451	switch (mQ.fQuadType)
8be1b0cc	452	{
8be1b0cc	453
ca462fa9	454	case QuadSet::QT_LineXYFixedZ:
8be1b0cc	455	{
ca462fa9	456	const Float_t& z = mQ.fDefCoord;
	457	while (qi.next()) {
	458	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	459	if (SetupColor(q))
	460	{
1545977c	461	if (flags.SecSelection()) glLoadName(qi.index());
1545977c	462	glBegin(GL_LINES);
253a61b0	463	glVertex3f(q.fA, q.fB, z);
253a61b0	464	glVertex3f(q.fA + q.fDx, q.fB + q.fDy, z);
1545977c	465	glEnd();
8be1b0cc	466	}
8be1b0cc	467	}
ca462fa9	468	break;
ca462fa9	469	}
8be1b0cc	470
ca462fa9	471	case QuadSet::QT_LineXZFixedY:
	472	{
	473	const Float_t& z = mQ.fDefCoord;
	474	while (qi.next()) {
	475	QuadSet::QLineFixC& q = * (QuadSet::QLineFixC*) qi();
	476	if (SetupColor(q))
	477	{
1545977c	478	if (flags.SecSelection()) glLoadName(qi.index());
1545977c	479	glBegin(GL_LINES);
253a61b0	480	glVertex3f(q.fA, z, q.fB);
253a61b0	481	glVertex3f(q.fA + q.fDx, z, q.fB + q.fDy);
1545977c	482	glEnd();
8be1b0cc	483	}
8be1b0cc	484	}
ca462fa9	485	break;
ca462fa9	486	}
8be1b0cc	487
ca462fa9	488	default:
ca462fa9	489	throw(eH + "unsupported quad-type.");
8be1b0cc	490
8be1b0cc	491	}
ca462fa9	492
1545977c	493	if (flags.SecSelection()) glPopName();
8be1b0cc	494	}
96c51586	495
1545977c	496	void QuadSetGL::RenderHexagons(const TGLDrawFlags &flags) const
96c51586	497	{
	498	static const Exc_t eH("QuadSetGL::RenderHexagons ");
	499
	500	const Float_t sqr3hf = 0.5*TMath::Sqrt(3);
	501
	502	QuadSet& mQ = * fM;
	503
ca462fa9	504	GLenum primitveType = (mQ.fRenderMode != QuadSet::RM_Line) ?
ca462fa9	505	GL_POLYGON : GL_LINE_LOOP;
96c51586	506
ca462fa9	507	glNormal3f(0, 0, 1);
96c51586	508
ca462fa9	509	VoidCPlex::iterator qi(mQ.fPlex);
96c51586	510
1545977c	511	if (flags.SecSelection()) glPushName(0);
1545977c	512
ca462fa9	513	switch (mQ.fQuadType)
96c51586	514	{
96c51586	515
ca462fa9	516	case QuadSet::QT_HexagonXY:
96c51586	517	{
ca462fa9	518	while (qi.next()) {
	519	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	520	if (SetupColor(q))
96c51586	521	{
ca462fa9	522	const Float_t rh = q.fR * 0.5;
ca462fa9	523	const Float_t rs = q.fR * sqr3hf;
1545977c	524	if (flags.SecSelection()) glLoadName(qi.index());
ca462fa9	525	glBegin(primitveType);
253a61b0	526	glVertex3f( q.fR + q.fA, q.fB, q.fC);
	527	glVertex3f( rh + q.fA, rs + q.fB, q.fC);
	528	glVertex3f( -rh + q.fA, rs + q.fB, q.fC);
	529	glVertex3f(-q.fR + q.fA, q.fB, q.fC);
	530	glVertex3f( -rh + q.fA, -rs + q.fB, q.fC);
	531	glVertex3f( rh + q.fA, -rs + q.fB, q.fC);
ca462fa9	532	glEnd();
96c51586	533	}
ca462fa9	534	}
	535	break;
	536	}
96c51586	537
ca462fa9	538	case QuadSet::QT_HexagonYX:
	539	{
	540	while (qi.next()) {
	541	QuadSet::QHex& q = * (QuadSet::QHex*) qi();
	542	if (SetupColor(q))
96c51586	543	{
ca462fa9	544	const Float_t rh = q.fR * 0.5;
ca462fa9	545	const Float_t rs = q.fR * sqr3hf;
1545977c	546	if (flags.SecSelection()) glLoadName(qi.index());
ca462fa9	547	glBegin(primitveType);
253a61b0	548	glVertex3f( rs + q.fA, rh + q.fB, q.fC);
	549	glVertex3f( q.fA, q.fR + q.fB, q.fC);
	550	glVertex3f(-rs + q.fA, rh + q.fB, q.fC);
	551	glVertex3f(-rs + q.fA, -rh + q.fB, q.fC);
	552	glVertex3f( q.fA, -q.fR + q.fB, q.fC);
	553	glVertex3f( rs + q.fA, -rh + q.fB, q.fC);
ca462fa9	554	glEnd();
96c51586	555	}
ca462fa9	556	}
	557	break;
	558	}
96c51586	559
ca462fa9	560	default:
ca462fa9	561	throw(eH + "unsupported quad-type.");
96c51586	562
ca462fa9	563	} // end switch quad-type
96c51586	564
1545977c	565	if (flags.SecSelection()) glPopName();
	566	}
	567
	568	/**************************************************************************/
	569	/**************************************************************************/
	570
	571	//______________________________________________________________________________
	572	void QuadSetGL::ProcessSelection(UInt_t* ptr, TGLViewer, TGLScene)
	573	{
	574	// Processes secondary selection from TGLViewer.
	575	// Calls TPointSet3D::PointSelected(Int_t) with index of selected
	576	// point as an argument.
	577
	578	if (ptr[0] < 2) return;
	579	fM->QuadSelected(ptr[4]);
96c51586	580	}