[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 <TGLRnrCtx.h>
#include <TGLSelectRecord.h>
#include <TGLIncludes.h>

using namespace Reve;

//______________________________________________________________________
// OldQuadSetGL
//

ClassImp(OldQuadSetGL)

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

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

OldQuadSetGL::~OldQuadSetGL()
{}

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

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

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

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

void OldQuadSetGL::DirectDraw(TGLRnrCtx & /*rnrCtx*/) const
{
  // printf("OldQuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", rnrCtx.Style(), rnrCtx.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)
{
  // fDLCache = false; // Disable DL.
}

QuadSetGL::~QuadSetGL()
{}

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

Bool_t QuadSetGL::SetModel(TObject* obj, const Option_t* /*opt*/)
{
  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(TGLRnrCtx & rnrCtx) const
{
  static const Exc_t eH("QuadSetGL::DirectDraw ");

  // printf("QuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", rnrCtx.Style(), rnrCtx.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(rnrCtx);
  else if (mQ.fQuadType < QuadSet::QT_Line_End)      RenderLines(rnrCtx);
  else if (mQ.fQuadType < QuadSet::QT_Hexagon_End)   RenderHexagons(rnrCtx);

  glPopAttrib();

}


void QuadSetGL::RenderQuads(TGLRnrCtx & rnrCtx) 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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.SecSelection()) glPopName();
}


void QuadSetGL::RenderLines(TGLRnrCtx & rnrCtx) const
{
  static const Exc_t eH("QuadSetGL::RenderLines ");

  QuadSet& mQ = * fM;

  VoidCPlex::iterator qi(mQ.fPlex);

  if (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.SecSelection()) glPopName();
}

void QuadSetGL::RenderHexagons(TGLRnrCtx & rnrCtx) 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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.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 (rnrCtx.SecSelection()) glPopName();
}

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

//______________________________________________________________________________
void QuadSetGL::ProcessSelection(TGLRnrCtx & /*rnrCtx*/, TGLSelectRecord & rec)
{
  // Processes secondary selection from TGLViewer.
  // Calls TPointSet3D::PointSelected(Int_t) with index of selected
  // point as an argument.

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