TridGLFrame.cxx

Go to the documentation of this file.

#include "TridGLFrame.h"
#include "TridPage.h"
#include "TridSketches.h"
#include "TridOpenGLGlobal.h"
#include "TridControl.h"
#include "MessageService/MsgService.h"

#include "TROOT.h"
#include "TSystem.h"
#include "TGX11.h"
#include "TVirtualX.h"
#include "KeySymbols.h"

#include <GL/gl.h>
#include <GL/glx.h>
#include <GL/glu.h>
#include "glf.h"
#include <iostream>
#include <sys/time.h>
#include <string>
#include <cmath>

#ifdef USE_ASIMAGE
extern "C" {
  // do this to force code for ISO compliance:
#undef __GNUC__
#undef DEBUG
#undef LOCAL_DEBUG
#undef DEBUG_ALL
#   include "afterbase.h"
#   include "afterimage.h"
}
#endif

using namespace std;

CVSID("$Id: TridGLFrame.cxx,v 1.31 2007/09/14 14:12:19 tagg Exp $");


class TridGLFrameWindowHandler : public TGUnknownWindowHandler 
{
public:
  TridGLFrame* fGLFrame;
  Window       fWindow;
  TridGLFrameWindowHandler( TridGLFrame* glframe, Window whichWindow) 
  {
    fGLFrame = glframe;
    fWindow = whichWindow;
  };
  virtual ~TridGLFrameWindowHandler() {};
  
  virtual Bool_t HandleEvent(Event_t *event)
  {
    if((Window)(event->fWindow) == fWindow) {      
      return fGLFrame->HandleEvent(event);
    }    
    return false;
  }

private:
  TridGLFrameWindowHandler() {};
}; 



TridGLFrame::TridGLFrame(TridPage* tp, TGWindow& parent, TridControl* tc,
                         const TridPOV& min,
                         const TridPOV& max )
  : TGFrame(&parent, 400, 300),
    fTridControl(tc),
    fAnimTimeMin(-1e99), fAnimTimeMax(1e99) // Default animation time.
{
  fTridPage = tp;
  fMainFrame = dynamic_cast<const TGMainFrame*>(GetMainFrame());

  gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier,
                        kButtonPressMask | kButtonReleaseMask,
                        kNone, kNone);
  
  gVirtualX->SelectInput(fId, kKeyPressMask | kExposureMask | kPointerMotionMask |
                         kStructureNotifyMask);


  fDrawContext = NULL;
 
  Resize(GetDefaultSize());
  fWidth = GetWidth();
  fHeight = GetHeight();
  fAspectRatio = double(fWidth)/double(fHeight);
  MSG("TriD",Msg::kDebug)  << "Initial GLFrame size: " << fWidth << "   " << fHeight << endl;
  Layout();

  DeleteSketches();

  // Open the viewport, prepare for stuff.
  SetupOpenGL();

  // Set current Point of View to default (probably will be overriden.)
  SetPOV();
  
  // Set max range for user to move around (set to 'anywhere'):
  fPOVMin.Copy(min);
  fPOVMax.Copy(max);

  //cout << "Min: " << fPOVMin.AsString() << endl;
  //cout << "Max: " << fPOVMax.AsString() << endl;
  // State variables
  fButton = 0;
    
  // Do a draw into the view.
  Update();  
  MSG("TriD",Msg::kDebug) << "TridGLFrame constructor.  Window ID is " << fId << endl;
}



TridGLFrame::~TridGLFrame( void )
{
  if(fDrawContext) {
    glXDestroyContext(fDrawContext->fDisplay,fDrawContext->fglxContext);
    XUnmapWindow(fDrawContext->fDisplay, fDrawContext->fWindow);
    XDestroyWindow(fDrawContext->fDisplay, fDrawContext->fWindow);
    gClient->RemoveUnknownWindowHandler(fDrawContext->fHandler);
    delete fDrawContext->fHandler;
    delete fDrawContext;
  }
  MSG("TriD",Msg::kDebug) << "TridGLFrame destructor." << endl;
}

void TridGLFrame::SetupOpenGL( void )
{
  // Pull in the dynamic library, if neccessary
  // and start up GL and GLF:
  TridOpenGLGlobal::Instance().GlfLoadFont();

  // Make a new 'hider' object, which simply stores some
  // variables that OpenGL and GLX need to set the window up.
  fDrawContext = CreateDrawContext();

  glXMakeCurrent(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fglxContext); 
  
  // Set up the view.
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  SetupProjection();
}

TridGLFrame::DrawContext* TridGLFrame::CreateDrawContext(Int_t x, Int_t y, Int_t width, Int_t height)
{
  if(width  <0 ) width  = fWidth;
  if(height <0 ) height = fHeight;


    // Make a new 'hider' object, which simply stores some
  // variables that OpenGL and GLX need to set the window up.
  DrawContext* dc = new DrawContext;

  dc->fX = x;
  dc->fY = y;
  dc->fWidth  = width;
  dc->fHeight = height;
  
  // X11 code to initialize GL
  dc->fDisplay = (Display *) gVirtualX->GetDisplay();
  
  static int dblBuf[] = {
    GLX_DOUBLEBUFFER,
    GLX_RGBA, GLX_DEPTH_SIZE, 16,
    GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
    None
  };
  static int *snglBuf = &dblBuf[1];
  
  dc->fxVisInfo = glXChooseVisual(dc->fDisplay, DefaultScreen(dc->fDisplay), dblBuf);
  if (dc->fxVisInfo == 0)
    dc->fxVisInfo = glXChooseVisual(dc->fDisplay, DefaultScreen(dc->fDisplay), snglBuf);  
  
  if (dc->fxVisInfo == 0)
    MSG("TriD",Msg::kDebug) << "InitGLWindow: Error! Barf! No good visual" << endl;
  
  // Create OpenGL context.
  dc->fglxContext = glXCreateContext(dc->fDisplay, dc->fxVisInfo, None, GL_TRUE);    
  if(dc->fglxContext == 0) {
    MSG("TriD",Msg::kInfo) << "OpenGL: DRI unavailable; using indirect renderinging." << endl;
    dc->fglxContext = glXCreateContext(dc->fDisplay, dc->fxVisInfo, None, GL_FALSE);    // Set last parameter to false for indirect rendering.
  }

  
  // Create a window.
  int xval, yval;
  unsigned int wval, hval, border, depth;
  Window root, wind = (Window) GetId();
  XGetGeometry(dc->fDisplay, wind, &root, &xval, &yval, &wval, &hval, &border, &depth); 
  
  // window attributes
  ULong_t mask;
  XSetWindowAttributes attr; 
  
  attr.background_pixel = 0;
  attr.border_pixel = 0;
  attr.colormap = XCreateColormap(dc->fDisplay, root, dc->fxVisInfo->visual, AllocNone);
  attr.event_mask = NoEventMask;
  attr.backing_store = Always;
  attr.bit_gravity = NorthWestGravity;
  mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask |
    CWBackingStore | CWBitGravity;
  
  dc->fWindow = XCreateWindow(dc->fDisplay, wind, 
                              xval + x, yval + y, width, height,
                              0, dc->fxVisInfo->depth, InputOutput,
                              dc->fxVisInfo->visual, mask, &attr);
  
  XMapWindow(dc->fDisplay, dc->fWindow);

  // Tell ROOT how to handle events for this window.
  MSG("TriD",Msg::kDebug) << "GL window is " << dc->fWindow << endl;
  dc->fHandler = new TridGLFrameWindowHandler(this,dc->fWindow);
  gClient->AddUnknownWindowHandler(dc->fHandler);
  
  // Make sure expose events get to it. (Only trap expose events; we want everything else
  // to go to the fGLFrame that contains it. Far simpler that way.
  XSelectInput(dc->fDisplay, dc->fWindow, ExposureMask );
  glXMakeCurrent(dc->fDisplay, dc->fWindow, dc->fglxContext); 

  //ResizeViewport();

  return dc;
}


Bool_t TridGLFrame::HandleMotion( int button, int startx, int starty, int stopx, int stopy )
{
  int delx, dely;
  delx = stopx-startx;
  dely = stopy-starty;
  
  
  if(fButton == 0 ) {
    // The mouse is travelling.. pick and show.
    UInt_t name = Pick(stopx,stopy);
    if(name!=fPicked) {
      fPicked = name;
      fTridPage->MouseOver(fPicked);
      Update();
      return true;
      }
  } else if( button == kButton1 ) {
    // Rotate.
    if(abs(delx) + abs(dely)>0){
      fPOV.fPhi   += ((float)delx)/((float)fDrawContext->fWidth)*400.;
      fPOV.fTheta += ((float)dely)/((float)fDrawContext->fHeight)*400.;
      fPOV.Push();
      Update();      
      return true;
    }
  } else if( button == kButton2 ) {
    // Scale.  Towards center means shrink, away from center means grow.
    if(abs(delx) + abs(dely)>0){
      float sdx = (float)(startx - (fDrawContext->fWidth/2.));
      float sdy = (float)(starty - (fDrawContext->fHeight/2.));
      float dot = sdx*delx + sdy*dely;
      dot = dot/sqrt(sdy*sdy+sdx*sdx);
      
      fPOV.fDist -= dot*100/(double)(fDrawContext->fWidth);
      fPOV.PushIfChanged();
      Update();
      return true;
    }
  } else if( button == kButton3 ) {
    // Slide.
    if(abs(delx) + abs(dely)>0){
      // This mostly does what I want. Still some problems; must go back
      // when I understand the math a little better.
      GLfloat z;
      GLdouble x1, y1, z1;
      GLdouble x2, y2, z2;
      GLdouble  model[16];
      GLdouble  proj[16];
      GLint     view[4];
      glGetDoublev(GL_MODELVIEW_MATRIX, model);
      glGetDoublev(GL_PROJECTION_MATRIX, proj);
      glGetIntegerv(GL_VIEWPORT, view); 
      
      glReadPixels(startx, fHeight-starty, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z);
      gluUnProject(startx, fHeight-starty,  z, model, proj, view, &x1, &y1, &z1);
      gluUnProject(stopx,  fHeight-stopy,       z, model, proj, view, &x2, &y2, &z2);

      MSG("TriD",Msg::kDebug) << "Panning. ReadPixel z is " << z << endl;
      
      // NB all plotting is in x-z plane now.
      fPOV.fx -= x2-x1;
      fPOV.fy -= y2-y1;
      fPOV.fz -= z2-z1;
      
      fPOV.Push();
      Update();
      return true;
    }
  }
  return true;
}


Bool_t TridGLFrame::HandleMotion(Event_t* ev)
{
  HandleMotion(fButton, fMouseLast_x, fMouseLast_y, ev->fX, ev->fY );

  fButtonTraveled += abs(ev->fX - fMouseLast_x) + abs(ev->fY - fMouseLast_y);

  fMouseLast_x = ev->fX;
  fMouseLast_y = ev->fY;

  return true;
}

Bool_t TridGLFrame::HandleButton(Event_t *ev)
{
  
  if((ev->fCode == kButton1) || (ev->fCode == kButton2) || (ev->fCode == kButton3) ){
    if (ev->fType == kButtonPress) {
      fMouseLast_x = fMouseStart_x = ev->fX;
      fMouseLast_y = fMouseStart_y = ev->fY;
      fButtonTraveled = 0;
      fButton = ev->fCode;  // Note: ignores possible mulitple-presses.
    }
    else if (ev->fType == kButtonRelease) {
      if((fButtonTraveled<5)&&(fButton==kButton1)) {
        // This was a click-and-relase. Select.
        UInt_t name = Pick(fMouseStart_x,fMouseStart_y);
        if(name>0) fTridPage->MouseClick(name);
      } else {
        // It was not a click, but a drag.
        fPOV.PushIfChanged();
      }
      fButton = 0;
    }
  }
  
  else if(ev->fCode == kButton4) {
    if (ev->fType == kButtonPress) {
      // Zoom in.
      fPOV.fDist -=1; fPOV.PushIfChanged();
      Update();
    }
  }
  else if(ev->fCode == kButton5) {
    if (ev->fType == kButtonPress) {    
      // Zoom out.
      fPOV.fDist     +=1; fPOV.PushIfChanged();
      Update();
    }
  }
  
  //cout << "Got button" << endl;
  return true;
}

Bool_t TridGLFrame::HandleKey(Event_t *ev)
{
  if (ev->fType == kGKeyPress) {
    UInt_t keysym;
    char str[2];
    gVirtualX->LookupString(ev,(char*)str,sizeof(str),keysym);
    switch((EKeySym)keysym) {
    case kKey_q:
      fPOV.fz +=0.1;  
      break;
    case  kKey_a:
      fPOV.fz -=0.1;  
      break;
    case kKey_w:
      fPOV.fy +=0.1;  
      break;
    case  kKey_s:
      fPOV.fy-= 0.1;  
      break;
    case kKey_e:
      fPOV.fx+= 0.1;  
      break;
    case kKey_d:
      fPOV.fx-= 0.1;  
      break;
    case kKey_Up:
      // Zoom in.
      fPOV.fDist    -= 1;  
      break;
    case kKey_Down:
      // Zoom out
      fPOV.fDist    += 1;  
      break;
    case kKey_Left:
      fPOV.fPhi += 1;  
      break;
    case kKey_Right:
      fPOV.fPhi -= 1;  
      break;      
    default:
      break;
    }
  }

  fPOV.PushIfChanged();
  Update();
  return true;
}

Bool_t TridGLFrame::HandleContainerExpose(Event_t *ev)
{
   // Handle expose events.
  //cout << "Expose event (container)." << endl;
  if (ev->fCount == 0)
    Update();
  
  return kTRUE;
}

Bool_t TridGLFrame::HandleExpose(Event_t *ev)
{
   // Handle expose events.
  //cout << "Expose event." << endl;
  if (ev->fCount == 0)
    Update();
  
  return kTRUE;
}
 
Bool_t TridGLFrame::HandleConfigureNotify(Event_t* ev)
{
  // Handle configure (i.e. resize) event.
  fDrawContext->fWidth   = fWidth  = ev->fWidth;
  fDrawContext->fHeight  = fHeight = ev->fHeight;
  fAspectRatio = double(fWidth)/double(fHeight);
  Layout();
  ResizeViewport();
  Update();  
  return kTRUE;
}

void TridGLFrame::ResizeViewport()
{
  int xval, yval;
  unsigned int wval, hval, border, depth;
  Window root, wind = (Window) GetId();
  XGetGeometry(fDrawContext->fDisplay, wind, &root, &xval, &yval, &wval, &hval, &border, &depth); 
  XMoveWindow(fDrawContext->fDisplay, fDrawContext->fWindow, xval + fDrawContext->fX, yval + fDrawContext->fY);
  
  XResizeWindow(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fWidth, fDrawContext->fHeight);
  glXMakeCurrent(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fglxContext);
  glViewport(0, 0, (GLint) fDrawContext->fWidth, (GLint) fDrawContext->fHeight);
  
  // Set up the view.
  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  SetupProjection();
}



unsigned int TridGLFrame::Pick( int x, int y )
{
  const int BUFSIZE =512;
  static GLuint selectBuf[BUFSIZE];
  GLint hits;
  GLint viewport[4];  

  glXMakeCurrent(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fglxContext);

  // Get viewport coordinates (safest way of knowing width, height)
  glGetIntegerv (GL_VIEWPORT, viewport);
  
  // Give opengl selectBuf as the place to store hits.
  glSelectBuffer (BUFSIZE, selectBuf);

  // Tell OpenGL not to render, only to think about drawing.
  glRenderMode (GL_SELECT);

  // Make sure we're using names, set default to 0.
  glInitNames();
  glPushName(0);
  
  // This mimics the Update() command, but doesn't touch the screen.

  // Don't SetupProjection(), but instead do:
  glMatrixMode (GL_PROJECTION);
  glPushMatrix ();    // Push old projection onto stack.
  glLoadIdentity ();  
  //  create 5x5 pixel picking region near cursor location     
  gluPickMatrix ((GLdouble) x, (GLdouble) (viewport[3] - y),
                 4.0, 4.0, viewport);
  SetupProjection();  // Add in our custom projection.
  TransformToPOV();   // Set up coords
  DrawObjects();      // Draw stuff into the scene (Not the HUD or suchlike)
  
  // Now pop the matrix.
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  // Do it! (I don't know which of these does it.)
  glFlush();
  hits = glRenderMode(GL_RENDER);

  // We have the hits.. now process to find the best (i.e. topmost) hit.
  GLuint* ptr = (GLuint *) selectBuf;
  unsigned int bestName = 0;
  float bestZ = 99;

  for(int i=0;i<hits;i++) {
    unsigned int numNames = *ptr; // Number of names for this hit.
    ptr++;
    float z1 = float(*(ptr))/0x7fffffff;
    ptr++;
    float z2 = float(*(ptr))/0x7fffffff;
    ptr++;
    for(unsigned int j=0; j<numNames; j++) {
      unsigned int name = *ptr;
      ptr++;
      if(((z1+z2)<bestZ) && (name>0)) { bestName = name; bestZ = z1+z2; };
    }
  }
  return bestName;
}





void TridGLFrame::Update( void )
{
  // Clears and redraws the OpenGL viewport.

  struct timeval timestart,timeend;
  gettimeofday(&timestart,0);

  // Unsure that our window is the current one for OpenGL.
  // (This call must be atomic!)
  glXMakeCurrent(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fglxContext);
  
  // Draw operations.
  ClearViewport();      // Wipe blank. (Could be later, but we are double-buffering.)
  TransformToPOV();     // Set the cmera in world coordinates
  SetupOptions();       // Change OpenGL options
  SetupLighting();      // Put in light sources
  DrawObjects();        // Draw the Sketches
  DrawHUD(fHUDText.c_str());            // Put on the overlay.

  glFlush();            // Send commands to X server
  SwapBuffers();        // Swap the buffers to display it, if supported.

  gettimeofday(&timeend,0);
  
  fFrameTime = (timeend.tv_sec - timestart.tv_sec) +
    (timeend.tv_usec - timestart.tv_usec) * 0.000001;
}

void TridGLFrame::SetupProjection( void )
{
  gluPerspective(30.0f,(GLfloat)fDrawContext->fWidth/(GLfloat)fDrawContext->fHeight,0.1f,100.0f);
}

void TridGLFrame::ClearViewport()
{
  TVector3 bg = fTridControl->GetBackgroundColor();
  glClearColor(bg.x(),bg.y(),bg.y(),0.0);
  glClearDepth(1.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

void TridGLFrame::TransformToPOV( void )
{
  // Clip the POV so it conforms to limits.
  NormalizeAndClipPOV();

   // Need to manipulate the ModelView matrix to move our model around.
  glMatrixMode(GL_MODELVIEW);
  
  // Reset to 0,0,0; no rotation, no scaling.
  glLoadIdentity(); 
  
  // Pull back so we can look at it.
  glTranslatef(0.0f,0.0f,-fPOV.GetDist());
    
  // Rotate to our view.
  glRotatef(fPOV.GetTheta(),1.0f,0.0f,0.0f); // Rotate to elevation.
  if(fPOV.GetPhi()!=0)
    glRotatef(fPOV.GetPhi()  ,0.0f,1.0f,0.0f); // Rotate to side
  
  // Move to our viewpoint.
  glTranslatef(-fPOV.GetX(), -fPOV.GetY(), -fPOV.GetZ());  // Move to our viewpoint.
}

void TridGLFrame::SetupOptions( ) 
{
  // Enables Smooth Color Shading; try GL_FLAT for (lack of) fun.
  glShadeModel(GL_SMOOTH);
  glEnable(GL_DEPTH_TEST); // Disable depth test if blending
  // Allow antialiasing.
  glEnable(GL_LINE_SMOOTH);
  glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
}

void TridGLFrame::SetupLighting( Bool_t lighting_on )
{
  lighting_on = false;
  if(!lighting_on) {
    glDisable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
  } else {
    // A handy trick -- have surface material mirror the color.
    //glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);  
    
    glEnable(GL_LIGHTING);
    
    // Set up a light, turn it on.
    // Settings for our light.  Try playing with these (or add more lights).
    
    float Light_Ambient0[]=  { 0.3f, 0.3f, 0.3f, 1.0f };
    float Light_Diffuse0[]=  { 1.2f, 1.2f, 1.2f, 1.0f }; 
    float Light_Position0[]= { 0.0f, 8.0f, 12.0f, 1.0f };
    glLightfv(GL_LIGHT0, GL_POSITION, Light_Position0);
    glLightfv(GL_LIGHT0, GL_AMBIENT,  Light_Ambient0);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  Light_Diffuse0); 
    glEnable (GL_LIGHT0); 
    
    
    float Light_Ambient1[]=  { 0.3f, 0.3f, 0.3f, 1.0f };
    float Light_Diffuse1[]=  { 1.2f, 1.2f, 1.2f, 1.0f }; 
    float Light_Position1[]= { 0.0f, 8.0f, 0.0f, 1.0f };
    glLightfv(GL_LIGHT1, GL_POSITION, Light_Position1);
    glLightfv(GL_LIGHT1, GL_AMBIENT,  Light_Ambient1);
    glLightfv(GL_LIGHT1, GL_DIFFUSE,  Light_Diffuse1); 
    glEnable (GL_LIGHT1); 
  }
} 


void TridGLFrame::DrawObjects(  )
{
  glMatrixMode(GL_MODELVIEW); 
  TridSketchListItr itr = GetIterator();
  TridSketch* sketch;
  fNumSketches = 0;
  fNumSketchesDrawn = 0;

  const double opaque_thresh = 0.99;

  // Draw opaque objects first.
  itr.Reset();
  while( (sketch = itr.Next()) ){
    fNumSketches++;
    if(sketch->GetTransparency()>=opaque_thresh) {
      Bool_t drawn = sketch->Draw(fAnimTimeMin, fAnimTimeMax);
      if(drawn) fNumSketchesDrawn++;
    }
  }

  // Next, compute z-ordered list, and draw them in order.
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glEnable(GL_BLEND);
  glDepthMask(GL_FALSE);

  std::map<double,TridSketch*>           sortedSketches;
  std::map<double,TridSketch*>::iterator sortItr;

  double modelViewMatrix[16];
  glGetDoublev(GL_MODELVIEW_MATRIX, modelViewMatrix);

  itr.Reset();
  while( (sketch = itr.Next()) ){
    if(sketch->GetTransparency()<opaque_thresh) {
      double z = sketch->ComputeApparentZ(modelViewMatrix);
      sortedSketches[z]=sketch;
    }
  }
  
  for(sortItr = sortedSketches.begin(); sortItr!=sortedSketches.end(); sortItr++) 
    {
      sketch = sortItr->second;
      Bool_t drawn = sketch->Draw(fAnimTimeMin, fAnimTimeMax);
      if(drawn) fNumSketchesDrawn++;      
    }

  glDepthMask(GL_TRUE);

}
 

void TridGLFrame::DrawHUD( const char* text )
{ 
  //
  // Draws the 'heads up display'; overlay onto the 3d view, such as
  // feedback or controls.
  //

  // Custom coordinate system:
  // new coord system: left side is -1, right side is +1, aspect ratio 
  // determines height.
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  
  float yHeight = 1;
  if(fWidth>0) yHeight = (float)fHeight/(float)fWidth;
  gluOrtho2D(-1.0,1.0,-yHeight,yHeight);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glTranslatef(-0.99,-yHeight+0.02,0);

  
  
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_LIGHTING);
  glDisable(GL_DEPTH_TEST);
  
   glLoadName(0);
   glfStringCentering(GL_FALSE);
   glfSetRotateAngle(0.0f);
   glfStringDirection(GL_LEFT);

   glScalef(0.02,0.02,0.01);

   char buff[500];
   if(strlen(text)==0) {
     glColor4f(1.0f, 0.2f, 0.2f, 0.75f);
     sprintf(buff," (%3.1f,%3.1f,%4.1f) D:%4.1f Th:%3f Phi:%3f  Pick: %d  Render: %fs  Objects: %d/%d",
             fPOV.GetX(),fPOV.GetY(),fPOV.GetZ(),
             fPOV.GetDist(),fPOV.GetTheta(),fPOV.GetPhi(),fPicked,
             fFrameTime,
           fNumSketchesDrawn,fNumSketches);
   } else {
     glColor4f(1.0f, 0.9f, 0.9f, 0.75f);
     strncpy(buff,text,500);
   }
   glfDrawSolidString(buff);

   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
   glMatrixMode(GL_PROJECTION);
   glPopMatrix();
   
}

void TridGLFrame::SwapBuffers()
{
   // Swap two GL buffers.
 
   glXSwapBuffers(fDrawContext->fDisplay, fDrawContext->fWindow);   
   if (!glXIsDirect(fDrawContext->fDisplay, fDrawContext->fglxContext)) {
      glFinish();
   }
 
   // for help debugging, report any OpenGL errors that occur per frame
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR)  cerr << "SwapBuffers error. GL error: " <<gluErrorString(error) << endl;
}


void TridGLFrame::SetPOV( float x, float y, float z, float distance, float theta, float phi)
{
  // Sets the Point of View.0  // x,y,z: Coordinates of place to look at
  // distance: How far away from the point we are.
  // theta: elevation above or below the horizontal (degrees)
  // phi: rotation around the detector (degrees)
  fPOV.Set(x,y,z,distance,theta,phi);
  fPOV.Push();
}

void TridGLFrame::SetPOV( const TridPOV& in )
{
  // Sets the Point of View.0  // x,y,z: Coordinates of place to look at
  // distance: How far away from the point we are.
  // theta: elevation above or below the horizontal (degrees)
  // phi: rotation around the detector (degrees)
  fPOV.Copy(in);
  fPOV.Push();
}

void TridGLFrame::SetMinPOV( const TridPOV& in )
{
  fPOVMin.Copy(in);
}

void TridGLFrame::SetMaxPOV( const TridPOV& in )
{
  fPOVMin.Copy(in);
}

void TridGLFrame::NormalizeAndClipPOV( void ) 
{
  // Normalize the Phi coordinate.
  fPOV.fPhi = fmod(fPOV.fPhi+540.,360) - 180;

  if(fPOV.fx < fPOVMin.fx) fPOV.fx = fPOVMin.fx;
  if(fPOV.fy < fPOVMin.fy) fPOV.fy = fPOVMin.fy;
  if(fPOV.fz < fPOVMin.fz) fPOV.fz = fPOVMin.fz;
  if(fPOV.fDist  < fPOVMin.fDist)  fPOV.fDist  = fPOVMin.fDist;
  if(fPOV.fTheta < fPOVMin.fTheta) fPOV.fTheta = fPOVMin.fTheta;
  if(fPOV.fPhi   < fPOVMin.fPhi)   fPOV.fPhi   = fPOVMin.fPhi;

  if(fPOV.fx > fPOVMax.fx) fPOV.fx = fPOVMax.fx;
  if(fPOV.fy > fPOVMax.fy) fPOV.fy = fPOVMax.fy;
  if(fPOV.fz > fPOVMax.fz) fPOV.fz = fPOVMax.fz;
  if(fPOV.fDist  > fPOVMax.fDist) fPOV.fDist = fPOVMax.fDist;
  if(fPOV.fTheta > fPOVMax.fTheta) fPOV.fTheta = fPOVMax.fTheta;
  if(fPOV.fPhi   > fPOVMax.fPhi)   fPOV.fPhi   = fPOVMax.fPhi;  
}


void TridGLFrame::Print(const char* filename, const char* text)
{
  // Draw this frame into a file.
  
#ifdef USE_RAWDUMP
  // This version of the code uses a raw OpenGL dump of the backing store.
  // This works on the Mac OSX platform, and is probably the least platform-dependent
  // version of all the codes.

  // Unsure that our window is the current one for OpenGL.
  // (This call must be atomic!)
  glXMakeCurrent(fDrawContext->fDisplay, fDrawContext->fWindow, fDrawContext->fglxContext);
  // Do everything but swap buffers.
  ClearViewport();      // Wipe blank. (Could be later, but we are double-buffering.)
  TransformToPOV();     // Set the cmera in world coordinates
  SetupOptions();       // Change OpenGL options
  SetupLighting();      // Put in light sources
  DrawObjects();        // Draw the Sketches
  DrawHUD(text);        // User text.
  glFlush();            // Send commands to X server
  
  std::string rawfile = filename;
  rawfile += ".raw";
  RawDump(rawfile.c_str());

  const char* cmd = Form("convert -depth 8 -size %dx%d rgb:%s %s",
                         fWidth, fHeight,
                         rawfile.c_str(), filename);
  int retval = gSystem->Exec(cmd);
  if(retval) {
    MSG("TriD",Msg::kWarning) << "'convert' command failed. Raw file dumped: " << rawfile.c_str() << endl;
  } else {
    // Delete the temporary file.
    gSystem->Unlink(rawfile.c_str());
  }
  return;
#endif
  

#ifdef USE_ASIMAGE
  const char* dir  = gSystem->DirName(filename);
  const char* file = gSystem->BaseName(filename);
  ASImageFileTypes atype = ASIT_Gif;

  const char* suffix = file + strlen(file) -2;
  while(suffix>=file) {
    if(suffix[0]=='.') { suffix++; break; }
    suffix--;
  }

  if(strcmp(suffix,"xpm")==0) atype = ASIT_Xpm;  
  if(strcmp(suffix,"png")==0) atype = ASIT_Png;  
  if(strcmp(suffix,"jpg")==0) atype = ASIT_Jpeg;
  if(strcmp(suffix,"jpeg")==0) atype = ASIT_Jpeg;
  if(strcmp(suffix,"gif")==0) atype = ASIT_Gif;  
  if(strcmp(suffix,"tiff")==0) atype = ASIT_Tiff;  


  XImage* ximage = XGetImage(fDrawContext->fDisplay,
                             fDrawContext->fWindow,
                             fDrawContext->fX,
                             fDrawContext->fY,
                             fDrawContext->fWidth,
                             fDrawContext->fHeight,
                             XAllPlanes(), ZPixmap);
  if(ximage==NULL) {
    MSG("TriD",Msg::kWarning) << "Error in Print() - Couldn't make the XImage! " << endl;
    return;
  }
  
  Int_t screen  = gVirtualX->GetScreen();
  Int_t depth   = gVirtualX->GetDepth();
  Visual *vis   = (Visual*) gVirtualX->GetVisual();
  Colormap cmap = (Colormap) gVirtualX->GetColormap();
  ASVisual* asv =  create_asvisual_for_id(fDrawContext->fDisplay,
                                          screen, depth,
                                          XVisualIDFromVisual(vis), 
                                          cmap, 0);
  if(asv==0) {
    MSG("TriD",Msg::kWarning)  << "Couldn't make the ASVisual! " << endl;
    return;
  }
  
  ASImage* asimage = ximage2asimage(asv, ximage, 10); // 10 is compression from 0 to 100
  if(asimage==0) {
    cout << "Couldn't make the ASImage! " << endl;
    return;
  } 
  ASImageExportParams parms;
  switch (atype) {
  case ASIT_Xpm:
    parms.xpm.type = atype;
    parms.xpm.flags = EXPORT_ALPHA;
    parms.xpm.dither = 4;
    parms.xpm.opaque_threshold = 127;
    parms.xpm.max_colors = 512;
    break;
  case ASIT_Png:
    parms.png.type = atype;
    parms.png.flags = EXPORT_ALPHA;
    parms.png.compression = 50;
    break;
  case ASIT_Jpeg:
    parms.jpeg.type = atype;
    parms.jpeg.flags = 0;
    parms.jpeg.quality = ASIMAGE_QUALITY_GOOD; // also poor, fast, top
    break;
  case ASIT_Gif:
    parms.gif.type = atype;
    parms.gif.flags = EXPORT_ALPHA;
    parms.gif.dither = 0; 
    parms.gif.opaque_threshold = 0;
    break;
  case ASIT_Tiff:
    parms.tiff.type = atype;
    parms.tiff.flags = EXPORT_ALPHA;
    parms.tiff.rows_per_strip = 0;
    parms.tiff.compression_type = TIFF_COMPRESSION_JPEG;
    parms.tiff.jpeg_quality = 100;
    parms.tiff.opaque_threshold = 0;
           break;
  default:
    return;
  }

  if(
     ASImage2file( asimage, dir, file,
                   atype, &parms )
     ) 
    MSG("TriD",Msg::kInfo) << "Wrote file " << file << endl;
  else 
    MSG("TriD",Msg::kWarning) << "Write failed!" << endl;
  

  if(asimage) destroy_asimage(&asimage);
  if(ximage) XDestroyImage(ximage);

  return;
#endif

#ifdef USE_WRITEGIF


  Int_t wid = gVirtualX->OpenPixmap(fWidth,fHeight);
  gVirtualX->SelectWindow(wid);
  Window_t winid = gVirtualX->GetWindowID(wid);
  
  static int snglBuf[] = {
    GLX_RGBA, GLX_DEPTH_SIZE, 16,
    GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
    None
  };
  
  Display*     display = (Display *) gVirtualX->GetDisplay();
  XVisualInfo* xvisinfo = glXChooseVisual(display, DefaultScreen(display), snglBuf);  
  
  if (xvisinfo == 0)
    cout << "InitGLWindow: Error! Barf! No good visual" << endl;
  // Create OpenGL context.
  GLXContext glxContext = glXCreateContext(display, xvisinfo, None, GL_FALSE);    // Set last parameter to false for indirect rendering.
  
  GLXPixmap glxPixmap = glXCreateGLXPixmap( display, xvisinfo, (Pixmap) winid);

  glXMakeCurrent(display, glxPixmap, glxContext );
  glViewport(0, 0, (GLint) fWidth, (GLint) fHeight);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  SetupProjection();
  
  ClearViewport();      // Wipe blank. (Could be later, but we are double-buffering.)
  TransformToPOV();

  // Boring, boring, boring!
  glShadeModel(GL_FLAT);
  glDisable(GL_BLEND);
  SetupLighting(false);

  DrawObjects();
  glFlush();

  if (gVirtualX->WriteGIF(filename)) {
    cout << "Snap taken:" << filename << endl;
  } else {
    cout << "TVirtualX::WriteGIF() failed!" << endl;
  }

  glXDestroyGLXPixmap(display, glxPixmap);
  gVirtualX->ClosePixmap();
  glXDestroyContext( display, glxContext );

  return;
#endif

}



int TridGLFrame::RawDump(const char* filename)
{
  // 
  //    Write the current view to a file.
  //    File format will be raw.
  // 
  
   int i,j;
   FILE *fptr;
   unsigned char *image;


   /* Allocate our buffer for the image */
   if ((image = (unsigned char*) malloc(3*fWidth*fHeight*sizeof(char))) == NULL) {
      fprintf(stderr,"Failed to allocate memory for image\n");
      return 1;
   }

   glPixelStorei(GL_PACK_ALIGNMENT,1);

   /* Open the file */
   if ((fptr = fopen(filename,"w")) == NULL) {
      fprintf(stderr,"Failed to open file for window dump\n");
      return 1;
   }

   /* Copy the image into our buffer */
   glReadBuffer(GL_BACK_LEFT);
   glReadPixels(0,0,fWidth,fHeight,GL_RGB,GL_UNSIGNED_BYTE,image);

   /* Write the raw file */
   /* fprintf(fptr,"P6\n%d %d\n255\n",width,height); for ppm */
   for (j=fHeight-1;j>=0;j--) {
     for (i=0;i<(int)fWidth;i++) {
         fputc(image[3*j*fWidth+3*i+0],fptr);
         fputc(image[3*j*fWidth+3*i+1],fptr);
         fputc(image[3*j*fWidth+3*i+2],fptr);
      }
   }
   fclose(fptr);

   /* Clean up */
   free(image);
   return 0;
}

---