#if defined(_MSC_VER)
    #pragma warning( disable : 4786 )
#endif

#include <stdlib.h>
#if (!defined(WIN32) && !defined(macintosh)) || defined(__CYGWIN__)
#include <unistd.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <osg/Math>

#include <string>

#include <osgGLUT/Viewer>
#include <osgGLUT/GLUTEventAdapter>

#include <osg/Switch>
#include <osg/Billboard>
#include <osg/LOD>
#include <osg/Light>
#include <osg/LightSource>
#include <osg/Geode>
#include <osg/Group>
#include <osg/NodeVisitor>
#include <osg/LineSegment>
#include <osg/PolygonMode>
#include <osg/Texture>
#include <osg/Notify>

#include <osgDB/WriteFile>

#include <osgUtil/IntersectVisitor>
#include <osgUtil/DisplayListVisitor>
#include <osgUtil/SmoothingVisitor>
#include <osgUtil/TriStripVisitor>
#include <osgUtil/DisplayRequirementsVisitor>

#include <osgUtil/TrackballManipulator>
#include <osgUtil/FlightManipulator>
#include <osgUtil/DriveManipulator>

#include <osg/Version>
#include <osgUtil/Version>

#ifdef WIN32
#define USE_FLTK
#define USE_GLUT
#endif

#include <osgGLUT/glut>

#if defined(WIN32) && !defined(__CYGWIN__)
#include <sys/timeb.h>
#else
#endif

#include <osg/Timer>
osg::Timer g_timer;
osg::Timer_t g_initTime;

//static GLenum polymodes [] = { GL_FILL, GL_LINE, GL_POINT };
static osg::PolygonMode::Mode polymodes [] = { osg::PolygonMode::FILL, osg::PolygonMode::LINE, osg::PolygonMode::POINT };

// forward declare functions to be used in stats.
GLuint makeRasterFont(void);
void displaytext(int x, int y, char *s);
int writePrims( const int ypos, osg::Statistics& stats);

using namespace osg;
using namespace osgUtil;
using namespace osgGLUT;



Viewer* Viewer::s_theViewer = 0;

Viewer::Viewer()
{
    s_theViewer = this;

    polymode = 0;
    texture = 1;
    backface = 1;
    lighting = 1;
    flat_shade = 0;

    _printStats = 0; // gwm change from bool was : false;

    #ifdef SGV_USE_RTFS
    fs = new RTfs( RTFS_MODE_RTC_SPIN );
    frame_rate = 16;
    fs->setUpdateRate( frame_rate );
    #endif

    _viewFrustumCullingActive = true;
    _smallFeatureCullingActive = true;

    _two_sided_lighting=0;

    _useDisplayLists = true;

    _saveFileName = "saved_model.osg";

    osg::notify(osg::INFO)<<"Scene Graph Viewer (sgv)"<< std::endl;

//    osg::notify(osg::INFO)<<"   '"<<osgGetLibraryName()<<"' Version "<<osgGetVersion()<< std::endl;
//    osg::notify(osg::INFO)<<"   '"<<osgUtilGetLibraryName()<<"' Version "<<osgUtilGetVersion()<< std::endl;

    _initialTick = _timer.tick();
    _frameTick = _initialTick;
    frRate=0; // added by gwm to display fram Rate smoothed

    _focusedViewport = 0;         // The viewport with mouse/keyboard focus
    
    
    _frameStamp = new osg::FrameStamp;
    
    _displaySettings = new osg::DisplaySettings;
}


Viewer::~Viewer()
{
}

/** read the command line string list, removing any matched control sequences.*/
void Viewer::readCommandLine(std::vector<std::string>& commandLine)
{
    _displaySettings->readCommandLine(commandLine);
}

/**
  * Configure and open the GLUT window for this Viewer
  * 
  */
bool Viewer::open()
{
    if ( getNumViewports() <= 0 ) {
        osg::notify(osg::FATAL)<<"osgGLUT::Viewer::open() called with no Viewports registered."<< std::endl;
        return false;
    }

    // Verify all viewports have an active camera manipulator 
    unsigned int index = 0;
    ViewportList::iterator itr;
    for(itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr, ++index)
    {
        if (itr->_cameraManipList.empty())
        {
            osg::notify(osg::INFO)<<"osgGLUT::Viewer::open() called without any camara manipulators registered for a viewport,"<< std::endl;
            osg::notify(osg::INFO)<<"automatically registering trackball,flight and drive manipulators."<< std::endl;
            registerCameraManipulator(new osgUtil::TrackballManipulator, index);
            registerCameraManipulator(new osgUtil::FlightManipulator, index);
            registerCameraManipulator(new osgUtil::DriveManipulator, index);
        }

        if (!itr->_cameraManipulator.valid())
            selectCameraManipulator(0,index);
    }

    GLUTEventAdapter::setWindowSize( _wx, _wy, _ww, _wh );
    GLUTEventAdapter::setButtonMask(0);


    bool needQuadBufferStereo = false;

    // do we need quad buffer stereo?

    // Set the absolute viewport for each SceneView based on the
    //   relative viewport coordinates given to us
    for(itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr)
    {
        osgUtil::SceneView* sceneView = itr->sceneView.get();
        int view[4] = { int(itr->viewport[0]*_ww), int(itr->viewport[1]*_wh),
                        int(itr->viewport[2]*_ww), int(itr->viewport[3]*_wh) };

        sceneView->setViewport(view[0], view[1], view[2], view[3]);

        osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
        ea->adaptResize(clockSeconds(), 
                        view[0], view[1], 
                        view[0]+view[2], view[1]+view[3]);

        if (itr->_cameraManipulator->handle(*ea,*this))
        {
            //        osg::notify(osg::INFO) << "Handled reshape "<< std::endl;
        }

        const osg::DisplaySettings* vs = sceneView->getDisplaySettings();
        if (vs)
        {
            _displaySettings->merge(*vs);
        }
        else
        {
            // one does not already exist so attach the viewers visualsSettins to the SceneView
            sceneView->setDisplaySettings(_displaySettings.get());
        }

    }
    
    if (_displaySettings->getStereo() && 
        _displaySettings->getStereoMode()==osg::DisplaySettings::QUAD_BUFFER) needQuadBufferStereo = true;

    // traverse the scene graphs gathering the requirements of the OpenGL buffers.
    osgUtil::DisplayRequirementsVisitor drv;
    drv.setDisplaySettings(_displaySettings.get());
    for(itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr)
    {
        Node* node = itr->sceneView->getSceneData();
        if (node) node->accept(drv);
    }

    // set up each render stage to clear the appropriate buffers.
    GLbitfield clear_mask=0;
    if (_displaySettings->getRGB())              clear_mask |= GL_COLOR_BUFFER_BIT;
    if (_displaySettings->getDepthBuffer())      clear_mask |= GL_DEPTH_BUFFER_BIT;
    if (_displaySettings->getStencilBuffer())    clear_mask |= GL_STENCIL_BUFFER_BIT;

    for(itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr)
    {
        osgUtil::RenderStage *stage = itr->sceneView->getRenderStage();
        stage->setClearMask(clear_mask);
    }


    // set the GLUT display mode bit mask up to handle it.
    unsigned int displayMode=0;
    if (_displaySettings->getDoubleBuffer())     displayMode |= GLUT_DOUBLE;
    else                                         displayMode |= GLUT_SINGLE;
    if (_displaySettings->getRGB())              displayMode |= GLUT_RGB;
    if (_displaySettings->getDepthBuffer())      displayMode |= GLUT_DEPTH;
    if (_displaySettings->getAlphaBuffer())      displayMode |= GLUT_ALPHA;
    if (_displaySettings->getStencilBuffer())    displayMode |= GLUT_STENCIL;
    if (needQuadBufferStereo)                    displayMode |= GLUT_STEREO;

    // and we'll add in multisample so that on systems like Onyx's can
    // go ahead and use there loverly anti-aliasing.  This is ignored
    // by other systems I've come across so not need to worry about it.
    displayMode |= GLUT_MULTISAMPLE;
    
    osg::notify(osg::INFO)                                    <<"osgGLUT::Viewer::open() requesting displayMode = "<<displayMode<< std::endl;
    if (displayMode & GLUT_DOUBLE)      osg::notify(osg::INFO)<<"                        requesting GLUT_DOUBLE."<< std::endl;
    if (displayMode & GLUT_SINGLE)      osg::notify(osg::INFO)<<"                        requesting GLUT_SINGLE."<< std::endl; 
    if (displayMode & GLUT_RGB)         osg::notify(osg::INFO)<<"                        requesting GLUT_RGB."<< std::endl; 
    if (displayMode & GLUT_DEPTH)       osg::notify(osg::INFO)<<"                        requesting GLUT_DEPTH."<< std::endl; 
    if (displayMode & GLUT_ALPHA)       osg::notify(osg::INFO)<<"                        requesting GLUT_ALPHA."<< std::endl; 
    if (displayMode & GLUT_STENCIL)     osg::notify(osg::INFO)<<"                        requesting GLUT_STENCIL."<< std::endl; 
    if (displayMode & GLUT_MULTISAMPLE) osg::notify(osg::INFO)<<"                        requesting GLUT_MULTISAMPLE."<< std::endl; 
    if (displayMode & GLUT_STEREO)      osg::notify(osg::INFO)<<"                        requesting GLUT_STEREO."<< std::endl; 

    _displayMode = displayMode;

    return Window::open();
}



unsigned int Viewer::registerCameraManipulator(osgUtil::CameraManipulator* cm,
                                               unsigned int viewport)
{
    ViewportDef &viewp = _viewportList[viewport];
    unsigned int pos   = viewp._cameraManipList.size();
    viewp._cameraManipList.push_back(cm);
    return pos;
}


void Viewer::setFocusedViewport(unsigned int pos)
{
    if (pos>=_viewportList.size()) return;

    _focusedViewport = pos;
}


void Viewer::selectCameraManipulator(unsigned int pos, unsigned int viewport)
{
    if (viewport>=_viewportList.size()) return;

    ViewportDef &viewp = _viewportList[viewport];
    if (pos>=viewp._cameraManipList.size()) return;

    viewp._cameraManipulator = viewp._cameraManipList[pos];

    osgUtil::SceneView *sceneView = viewp.sceneView.get();
    viewp._cameraManipulator->setCamera(sceneView->getCamera());
    viewp._cameraManipulator->setNode(sceneView->getSceneData());

    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    viewp._cameraManipulator->init(*ea,*this);
}


void Viewer::requestWarpPointer(int x,int y)
{
    // glutWarpPointer core dumps if invoked before a GLUT window is open
    if ( !_is_open ) {
        osg::notify(osg::INFO)<<"osgGLUT::Viewer::requestWarpPointer() called with window closed; ignored."<< std::endl;
        return;
    }
    glutWarpPointer(x,y);
}


float Viewer::app(unsigned int viewport)
{
    osg::Timer_t beforeApp = _timer.tick();


    // update the camera manipulator.
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    ea->adaptFrame(_frameStamp->getReferenceTime());

    if (_viewportList[viewport]._cameraManipulator->handle(*ea,*this))
    {
        //        osg::notify(osg::INFO) << "Handled update frame"<< std::endl;
    }

    // do app traversal.
    
    getViewportSceneView(viewport)->setFrameStamp(_frameStamp.get());
    getViewportSceneView(viewport)->app();

    osg::Timer_t beforeCull = _timer.tick();

    return  _timer.delta_m(beforeApp,beforeCull);
}


float Viewer::cull(unsigned int viewport)
{
    osg::Timer_t beforeCull = _timer.tick();

    // do cull traversal.
    getViewportSceneView(viewport)->cull();

    osg::Timer_t beforeDraw = _timer.tick();

    return _timer.delta_m(beforeCull,beforeDraw);
}


float Viewer::draw(unsigned int viewport)
{
    osg::Timer_t beforeDraw = _timer.tick();

    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,_two_sided_lighting);

    // do draw traversal.
    getViewportSceneView(viewport)->draw();

    osg::Timer_t afterDraw = _timer.tick();

    return _timer.delta_m(beforeDraw,afterDraw);
}


int Viewer::mapWindowXYToSceneView(int x, int y)
{
    int ogl_y = _wh-y;

    int index = 0;
    for(ViewportList::iterator itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr, ++index)
    {
      if ( x >= int( itr->viewport[0]*_ww ) &&
           ogl_y  >= int( itr->viewport[1]*_wh ) &&
           x <= int( (itr->viewport[0]+itr->viewport[2])*_ww ) &&
           ogl_y  <= int( (itr->viewport[1]+itr->viewport[3])*_wh ) )
        return index;
    }
    return -1;
}

// GWM July 2001 - moved all draw stats to  Statistics structure, and related RenderBin
// GWM Sept 2001 - all draw stats now calculated by calls to <Drawable>->getStats(Statistic..)

void Viewer::showStats(const unsigned int /*viewport*/)
{ // collect stats for viewport
    static int maxbins=1; // count number of bins
    static GLfloat tmax=100;
    glViewport(0,0,_ww,_wh);
    float vh = _wh;

    glDisable( GL_DEPTH_TEST ); // to see the stats always
    glDisable( GL_ALPHA_TEST );
    glDisable( GL_LIGHTING );
    glDisable( GL_TEXTURE_2D );
    
    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadIdentity();
    // set tmax using hysteresis to prevent flip-flopping between two values of tmax
    // tmax is the scale for the stage timing graph
    if (times[2].timeFrame>360.0f && tmax<1600) tmax=1600;
    else if (times[2].timeFrame<300.0f && tmax>800) tmax=800;
    else if (times[2].timeFrame>180.0f && tmax<800) tmax=800;
    else if (times[2].timeFrame<150.0f && tmax>400) tmax=400;
    else if (times[2].timeFrame>90.0f && tmax<400) tmax=400;
    else if (times[2].timeFrame<75.0f && tmax>200) tmax=200;
    else if (times[2].timeFrame>45.0f && tmax<200) tmax=200;
    else if (times[2].timeFrame<36.0f && tmax>100) tmax=100;
    glOrtho(-0.1f*tmax, tmax*1.1f,0,vh,0,500);
    glDepthRange(0,1);
    
    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadIdentity();
    glDisable(GL_STENCIL_TEST); // dont want to count pixels set by performance graphs
    
    if (_printStats>0) { // output the text frame rate
        char clin[72]; // buffer to print
        glColor3f(1.0f,1.0f,0.0f);
        if (frRate>10.0f)
        {
            float smoothRatio = 0.4; // should be >0 and <= 1.0, 
                                     // lower the value greater smoothing.
            frRate=(1.0f-smoothRatio)*frRate+smoothRatio*frameRate(); // smooth out variations in frame rate
        }
        else
        {
            frRate=frameRate(); // frame rate so slow no need to smooth in frame rate
        }
        sprintf(clin,"%.1f Hz.", frRate);
        displaytext(0,(int)(0.98f*vh),clin);
    }
    
    if (_printStats>=Statistics::STAT_GRAPHS  && _printStats!=Statistics::STAT_PRIMSPERVIEW  && _printStats!=Statistics::STAT_PRIMSPERBIN) { // more stats - graphs this time
    
        int sampleIndex = 2;
        float timeApp=times[sampleIndex].timeApp;
        float timeCull=times[sampleIndex].timeCull;
        float timeDraw=times[sampleIndex].timeDraw;
        float timeFrame=times[sampleIndex].timeFrame;

        osg::Vec4 app_color(0.0f,1.0f,0.0f,1.0f);
        osg::Vec4 cull_color(1.0f,0.0f,1.0f,1.0f);
        osg::Vec4 draw_color(0.0f,1.0f,1.0f,1.0f);
        osg::Vec4 swap_color(1.0f,0.5f,0.5f,1.0f);
        osg::Vec4 frame_color(1.0f,1.0f,0.0f,1.0f);

        char clin[72]; // buffer to print
        glColor4fv((GLfloat * )&app_color);
        sprintf(clin,"App %.1f ms.", timeApp);
        displaytext((int)(.15f*tmax),(int)(0.98f*vh),clin);
 
        glColor4fv((GLfloat * )&cull_color);
        sprintf(clin,"Cull %.1f ms.", timeCull);
        displaytext((int)(.35*tmax),(int)(0.98f*vh),clin);

        glColor4fv((GLfloat * )&draw_color);
        sprintf(clin,"Draw %.1f ms.", timeDraw);
        displaytext((int)(.55*tmax),(int)(0.98f*vh),clin);

        glColor4fv((GLfloat * )&frame_color);
        sprintf(clin,"Frame %.1f ms.", timeFrame);
        displaytext((int)(.75*tmax),(int)(0.98f*vh),clin);

 /*       osg::notify(osg::NOTICE) << "Time of App  "<<timeApp<<"ms   "<< std::endl;
        osg::notify(osg::NOTICE) << "Time of Cull "<<timeCull<<"ms   "<< std::endl;
        osg::notify(osg::NOTICE) << "Time of Draw "<<timeDraw<<"ms   "<< std::endl;
        osg::notify(osg::NOTICE) << "Frame time   "<<frameTime<< std::endl;
        osg::notify(osg::NOTICE) << "frameRate() = "<<frameRate()<< std::endl;*/

        glLineWidth(2.0f);
        glBegin(GL_LINE_LOOP );
        // yellow frame/grid in front of stats, units of .01 sec(?)
        glColor3f(.6f,.6f,0.0f);
        glVertex2f(0.0,0.97f*vh);
        glVertex2f(tmax,0.97f*vh);
        glVertex2f(tmax,0.88f*vh);
        glVertex2f(0.0,0.88f*vh);
        glEnd();
        glBegin(GL_LINES);
        // time marks
        int i;
        for (i=10; i<tmax; i+=10) {
            if ((i%100) == 0) glColor3f(.6f,.0f,0.0f); // red mark every 0.1 sec
            else glColor3f(.6f,.6f,0.0f); // yellow every 0.01 sec
            glVertex2f(i,0.97f*vh);
            glVertex2f(i,0.88f*vh);
        }
        // plot time for app, cull, draw, frame...
        float tstart=0;
        for (i=0; i<3; i++) {
            glColor4fv((GLfloat * )&app_color);
            glVertex2f(tstart,0.95f*vh);
            glVertex2f(tstart+times[i].timeApp,0.95f*vh);
            glColor4fv((GLfloat * )&cull_color);
            glVertex2f(tstart+times[i].timeApp,0.93f*vh);
            glVertex2f(tstart+times[i].timeApp+times[i].timeCull, 0.93f*vh);
            glColor4fv((GLfloat * )&draw_color);
            glVertex2f(tstart+times[i].timeApp+times[i].timeCull, 0.91f*vh);
            glVertex2f(tstart+times[i].timeApp+times[i].timeCull+times[i].timeDraw, 0.91f*vh);
            glColor4fv((GLfloat * )&swap_color);
            glVertex2f(tstart+times[i].timeApp+times[i].timeCull+times[i].timeDraw, 0.90f*vh);
            glVertex2f(tstart+times[i].timeFrame, 0.90f*vh);
            tstart+=times[i].timeFrame;
        }
        glEnd();
        glLineWidth(1.0f);
    }
    if (_printStats==Statistics::STAT_PRIMS) { // yet more stats - add triangles, number of strips...
    /* 
       * Use the new renderStage.  Required mods to RenderBin.cpp, and RenderStage.cpp (add getPrims)
       * also needed to define a new class called Statistic (see osgUtil/Statistic).
       * RO, July 2001.
        */
        
        ViewportList::iterator itr;
        Statistics primStats;
        for(itr=_viewportList.begin();
            itr!=_viewportList.end();
            ++itr)
        {
            osgUtil::RenderStage *stage = itr->sceneView->getRenderStage();
            stage->getPrims(&primStats);
        }
        primStats.setType(Statistics::STAT_PRIMS); // full print out required
        writePrims((int)(0.86f*vh),primStats);
        maxbins=(primStats.getBins()>maxbins)?primStats.getBins():maxbins;

    }
    if (_printStats==Statistics::STAT_PRIMSPERBIN) { // more stats - add triangles, number of strips... as seen per bin
    /* 
       * Use the new renderStage.  Required mods to RenderBin.cpp, and RenderStage.cpp (add getPrims)
       * also needed to define a new class called Statistic (see osgUtil/Statistic).
       * RO, July 2001.
        */
        
        Statistics *primStats=new Statistics[maxbins]; // array of bin stats
        ViewportList::iterator itr;
        for(itr=_viewportList.begin();
            itr!=_viewportList.end();
            ++itr)
        {
            osgUtil::RenderStage *stage = itr->sceneView->getRenderStage();
            stage->getPrims(primStats, maxbins);
        }
        int nbinsUsed=(primStats[0].getBins()<maxbins)?primStats[0].getBins():maxbins;
        int ntop=0; // offset
        for (int i=0; i<nbinsUsed; i++) {
            primStats[i].setType(Statistics::STAT_PRIMSPERBIN); // cuts out vertices & triangles to save space on screen
            ntop+=writePrims((int)(0.96f*vh-ntop),primStats[i]);
             osg::notify(osg::INFO) << "ntop "<< ntop<< std::endl;
        }
        maxbins=(primStats[0].getBins()>maxbins)?primStats[0].getBins():maxbins;
        delete [] primStats; // free up
    }
    if (_printStats==Statistics::STAT_DC) { // yet more stats - read the depth complexity
        int wid=_ww, ht=_wh; // temporary local screen size - must change during this section
        if (wid>0 && ht>0) {
            const int blsize=16;
            char *clin=new char[wid/blsize+2]; // buffer to print dc
            char ctext[128]; // buffer to print details
            float mdc=0;
            GLubyte *buffer=new GLubyte[wid*ht];
            if (buffer) {
                glPixelStorei(GL_PACK_ALIGNMENT, 1); // no extra bytes at ends of rows- easier to analyse
                glColor3f(.9f,.9f,0.0f);
                glReadPixels(0,0,wid,ht, GL_STENCIL_INDEX ,GL_UNSIGNED_BYTE, buffer);
                for (int j=0; j<ht; j+=blsize) { // break up screen into blsize*blsize pixel blocks
                    char *clpt=clin; // moves across the clin to display lines of text
                    for (int i=0; i<wid; i+=blsize) { // horizontal pixel blocks
                        int dc=0;
                        int nav=0; // number of pixels averaged for DC calc
                        for (int jj=j; jj<j+blsize; jj++) {
                            for (int ii=i; ii<i+blsize; ii++) {
                                if (jj<ht && ii<wid && jj>=0 && ii>=0) {
                                    dc+=buffer[ii+ (ht-jj-1)*wid];
                                    nav++;
                                }
                            }
                        }
                        mdc+=dc;
                        if (dc<nav) *clpt= ' '+(10*dc)/nav; // fine detail in dc=[0,1]; 0.1 increment in display, space for empty areas
                        else if (dc<80*nav) *clpt= '0'+dc/nav; // show 1-9 for DC=1-9; then ascii to 127
                        else *clpt= '+'; // too large a DC - use + to show over limit
                        clpt++;
                    }
                    *clpt='\0';
                    displaytext(0,(int)(0.84f*vh-(j*12)/blsize),clin); // display average DC over the blsize box
                }
                sprintf(ctext, "Pixels hit %.1f Mean DC %.2f: %4d by %4d pixels.", mdc, mdc/(wid*ht), wid, ht);
                displaytext(0,(int)(0.86f*vh),ctext);
                
                glEnable(GL_STENCIL_TEST); // re-enable stencil buffer counting
                delete [] buffer;
            }
            delete [] clin;
        }
    }

    glMatrixMode( GL_MODELVIEW );
    glPopMatrix();

    glMatrixMode( GL_PROJECTION );
    glPopMatrix();
}


void Viewer::display()
{

    _frameStamp->setFrameNumber(_frameStamp->getFrameNumber()+1);
    _frameStamp->setReferenceTime(clockSeconds());

    // application traverasal.
    times[2].timeApp=0.0f;

    // cull traverasal.
    times[2].timeCull=0.0f;

    // draw traverasal.
    times[2].timeDraw=0.0f;
    
    for(int i = 0; i < getNumViewports(); i++ )
    {
        // application traverasal.
        times[2].timeApp+=app(i);

        // cull traverasal.
        times[2].timeCull+=cull(i);

        // draw traverasal.
        times[2].timeDraw+=draw(i);
        if (_printStats==Statistics::STAT_PRIMSPERVIEW)
        { // gwm - get and show stats in each window
            showStats(i);
        }

    }


    if (_printStats>1) glFinish();

    times[2].frameend=updateFrameTick(); // absolute time

    times[2].timeFrame=frameSeconds()*1000;

    if (_printStats) {
        showStats(0); // output selected stats at this point - timing graph.
        times[0]=times[1]; // move the times buffers down
        times[1]=times[2];
    }

    glutSwapBuffers(); // moved after draw of stats & glFinish() to get accurate timing (excluding stat draw!)
    //    cout << "Time elapsed "<<_timer.delta_s(_initialTick,_timer.tick())<< std::endl;

    if (_printStats>1) glFinish();

    #ifdef SGV_USE_RTFS
    fs->frame();
    #endif
}


void Viewer::reshape(GLint w, GLint h)
{
    Window::reshape(w,h);

    // Propagate new window size to viewports
    for(ViewportList::iterator itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr)
    {
        osgUtil::SceneView* sceneView = itr->sceneView.get();
        int view[4] = { int(itr->viewport[0]*_ww), int(itr->viewport[1]*_wh),
                        int(itr->viewport[2]*_ww), int(itr->viewport[3]*_wh) };

        sceneView->setViewport(view[0], view[1], view[2], view[3]);

        osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
        ea->adaptResize(clockSeconds(), 
                        view[0], view[1], 
                        view[0]+view[2], view[1]+view[3]);

        if (itr->_cameraManipulator->handle(*ea,*this))
        {
            //        osg::notify(osg::INFO) << "Handled reshape "<< std::endl;
        }
    }
}


void Viewer::mouseMotion(int x, int y)
{
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    ea->adaptMouseMotion(clockSeconds(),x,y);

    if (_viewportList[_focusedViewport]._cameraManipulator->handle(*ea,*this))
    {
        //        osg::notify(osg::INFO) << "Handled mouseMotion "<<ea->_buttonMask<<" x="<<ea->_mx<<" y="<<ea->_my<< std::endl;
    }

    _mx = x;
    _my = y;

}


void Viewer::mousePassiveMotion(int x, int y)
{
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    ea->adaptMousePassiveMotion(clockSeconds(),x,y);

    // Switch viewport focus if no buttons are pressed
    if (ea->getButtonMask() == 0)
    {
        int focus = mapWindowXYToSceneView(x,y);
        if (focus >= 0 && focus != int(_focusedViewport))
          setFocusedViewport(focus);
    }

    if (_viewportList[_focusedViewport]._cameraManipulator->handle(*ea,*this))
    {
        //        osg::notify(osg::INFO) << "Handled mousePassiveMotion "<<ea->_buttonMask<<" x="<<ea->_mx<<" y="<<ea->_my<< std::endl;
    }
}


void Viewer::mouse(int button, int state, int x, int y)
{
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    ea->adaptMouse(clockSeconds(),button,state,x,y);

    // Switch viewport focus if button is pressed, and it is the only one
    unsigned mask = ea->getButtonMask();
    if (state == GLUT_DOWN && 
        (mask == osgUtil::GUIEventAdapter::LEFT_BUTTON   || 
         mask == osgUtil::GUIEventAdapter::MIDDLE_BUTTON || 
         mask == osgUtil::GUIEventAdapter::RIGHT_BUTTON))
    {
        int focus = mapWindowXYToSceneView(x,y);
        if (focus >= 0 && focus != int(_focusedViewport))
          setFocusedViewport(focus);
    }

    if (_viewportList[_focusedViewport]._cameraManipulator->handle(*ea,*this))
    {
        //        osg::notify(osg::INFO) << "Handled mouse "<<ea->_buttonMask<<" x="<<ea->_mx<<" y="<<ea->_my<< std::endl;
    }

}


void Viewer::keyboard(unsigned char key, int x, int y)
{
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;
    ea->adaptKeyboard(clockSeconds(),key,x,y);

    if (_viewportList[_focusedViewport]._cameraManipulator->handle(*ea,*this)) 
      return;

    if (key>='1' && key<='3')
    {
        int pos = key-'1';
        selectCameraManipulator(pos);
    }

    osgUtil::SceneView* sceneView = getViewportSceneView(_focusedViewport);

    switch( key )
    {

        case '7' :
            sceneView->setBackgroundColor(osg::Vec4(0.0f,0.0f,0.0f,1.0f));
            break;

        case '8' :
            sceneView->setBackgroundColor(osg::Vec4(0.2f, 0.2f, 0.4f, 1.0f));
            break;

        case '9' :
            sceneView->setBackgroundColor(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
            break;

        case '/' :
            if (sceneView->getLODBias()>0.5) sceneView->setLODBias(sceneView->getLODBias()/1.5f);
            break;

        case '*' :
            if (sceneView->getLODBias()<30) sceneView->setLODBias(sceneView->getLODBias()*1.5f);
            break;

        case '+' :
        #ifdef SGV_USE_RTFS
            frame_rate <<= 1;
            fs->stop();
            fs->setUpdateRate( frame_rate );
            fs->start();
        #endif
            break;

        case '-' :
        #ifdef SGV_USE_RTFS
            frame_rate >>= 1;
            if( frame_rate < 1 ) frame_rate = 1;
            fs->stop();
            fs->setUpdateRate( frame_rate );
            fs->start();
        #endif
            break;

        case 'd' :
            _useDisplayLists = !_useDisplayLists;
            if (_useDisplayLists)
            {
                // traverse the scene graph setting up all osg::GeoSet's so they will use
                // OpenGL display lists.
                osgUtil::DisplayListVisitor dlv(osgUtil::DisplayListVisitor::SWITCH_ON_DISPLAY_LISTS);
                sceneView->getSceneData()->accept(dlv);
                osg::notify(osg::NOTICE) << "Switched on use of OpenGL Display Lists."<< std::endl;
            }
            else
            {
                // traverse the scene graph setting up all osg::GeoSet's so they will use
                // OpenGL display lists.
                osgUtil::DisplayListVisitor dlv(osgUtil::DisplayListVisitor::SWITCH_OFF_DISPLAY_LISTS);
                sceneView->getSceneData()->accept(dlv);
                osg::notify(osg::NOTICE) << "Switched off use of OpenGL Display Lists."<< std::endl;
            }
            break;

        case 'p' :
            if (_printStats==Statistics::STAT_DC) glDisable(GL_STENCIL_TEST); // switch off stencil counting
            _printStats++; //gwm jul 2001 range of possible outputs, 0-4 = !_printStats;
            if (_printStats>=Statistics::STAT_RESTART) _printStats=0;
            if (getNumViewports()<=1 && _printStats==Statistics::STAT_PRIMSPERVIEW) _printStats++; // no need for these stats as only one view
            if (_printStats==Statistics::STAT_DC) { // count depth complexity by incrementing the stencil buffer every 
                // time a pixel is hit
                GLint nsten=0; // Number of stencil planes available
                glGetIntegerv(GL_STENCIL_BITS , &nsten);
                if (nsten>0) {
                    glEnable(GL_STENCIL_TEST);
                    glStencilOp(GL_INCR ,GL_INCR ,GL_INCR);
                } else {// skip this option
                    _printStats++;
                }
            }
            break;

        case 's' :
            flat_shade = 1  - flat_shade ;
            if( flat_shade )
                glShadeModel( GL_FLAT );
            else
                glShadeModel( GL_SMOOTH );

            break;

        case 'S' :
        {
            osg::notify(osg::NOTICE) << "Smoothing scene..."<< std::endl;
            osgUtil::SmoothingVisitor sv;
            sceneView->getSceneData()->accept(sv);
            osg::notify(osg::NOTICE) << "Smoothed scene."<< std::endl;
        }

        break;

        case 'R' :
        {
            osg::notify(osg::NOTICE) << "Tri Striping scene..."<< std::endl;
            osgUtil::TriStripVisitor tsv;
            sceneView->getSceneData()->accept(tsv);
            osg::notify(osg::NOTICE) << "Tri Striping scene scene."<< std::endl;
        }

        break;

        case 'b' :

            backface = 1 - backface;
            if( backface )
                sceneView->getGlobalStateSet()->setMode(GL_CULL_FACE,osg::StateAttribute::ON);
            else
                sceneView->getGlobalStateSet()->setMode(GL_CULL_FACE,osg::StateAttribute::OVERRIDE_OFF);

            break;

        case 'l' :
            lighting = 1  - lighting ;
            if( lighting )
                sceneView->getGlobalStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::OVERRIDE_ON);
            else
                sceneView->getGlobalStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::OVERRIDE_OFF);
            break;

        case 'L' :
        {
            osgUtil::SceneView::LightingMode lm= sceneView->getLightingMode();
            switch(lm)
            {
                case(osgUtil::SceneView::HEADLIGHT) : lm = osgUtil::SceneView::SKY_LIGHT; break;
                case(osgUtil::SceneView::SKY_LIGHT) : lm = osgUtil::SceneView::NO_SCENEVIEW_LIGHT; break;
                case(osgUtil::SceneView::NO_SCENEVIEW_LIGHT) : lm = osgUtil::SceneView::HEADLIGHT; break;
            }
            sceneView->setLightingMode(lm);
            break;
        }
        case 't' :
            texture = 1 - texture;
            if (texture)
            {
                sceneView->getGlobalStateSet()->setModeToInherit(GL_TEXTURE_2D);
//                sceneView->getGlobalStateSet()->setAttributeToInherit(osg::StateAttribute::TEXTURE);
            }
            else
            {
                // use blank texture to override all local texture in scene graph.
                // thus causing them to all use the same texture attribute, hence
                // preventing a state attribute change due to unused textures.
                static osg::ref_ptr<osg::Texture> blank_texture = new osg::Texture;
                sceneView->getGlobalStateSet()->setMode(GL_TEXTURE_2D,osg::StateAttribute::OVERRIDE_OFF);
//                sceneView->getGlobalStateSet()->setAttribute(blank_texture.get(),true);
            }
            break;

        case 'T' :
            _two_sided_lighting = 1 - _two_sided_lighting;
            break;

        case 'w' :
            {
                polymode = (polymode+1)%3;
                osg::PolygonMode* polyModeObj = new osg::PolygonMode;
                polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK,polymodes[polymode]);
                sceneView->getGlobalStateSet()->setAttribute(polyModeObj);
            }
            break;

        case 'f' :
            _fullscreen = !_fullscreen;
            if (_fullscreen)
            {
                _saved_ww = _ww;
                _saved_wh = _wh;
                glutFullScreen();
            } else
            {
                //glutPositionWindow(wx,wy);
                glutReshapeWindow(_saved_ww,_saved_wh);
            }
            break;

        case 'o' :
            if (sceneView->getSceneData() && osgDB::writeNodeFile(*sceneView->getSceneData(), _saveFileName))
            {
                osg::notify(osg::NOTICE) << "Saved scene to '"<<_saveFileName<<"'"<< std::endl;
            }
            break;

        case 'c' :
            _smallFeatureCullingActive = !_smallFeatureCullingActive;
            sceneView->getCullVisitor()->setCullingMode((osgUtil::CullViewState::CullingMode)
                ((_smallFeatureCullingActive ? osgUtil::CullViewState::SMALL_FEATURE_CULLING : osgUtil::CullViewState::NO_CULLING) |
                (_viewFrustumCullingActive ? osgUtil::CullViewState::VIEW_FRUSTUM_CULLING : osgUtil::CullViewState::NO_CULLING)));
            if (_smallFeatureCullingActive)
            {
                osg::notify(osg::NOTICE) << "Small feature culling switched on   "<< std::endl;
            }
            else
            {
                osg::notify(osg::NOTICE) << "Small feature culling switched off  "<< std::endl;
            }
            break;

        case 'C' :
            _viewFrustumCullingActive = !_viewFrustumCullingActive;
            if (_viewFrustumCullingActive)
            {
                osg::notify(osg::NOTICE) << "View frustum culling switched on   "<< std::endl;
            }
            else
            {
                osg::notify(osg::NOTICE) << "View frustum culling switched off  "<< std::endl;
            }
            sceneView->getCullVisitor()->setCullingMode((osgUtil::CullViewState::CullingMode)
                ((_smallFeatureCullingActive ? osgUtil::CullViewState::SMALL_FEATURE_CULLING : osgUtil::CullViewState::NO_CULLING) |
                (_viewFrustumCullingActive ? osgUtil::CullViewState::VIEW_FRUSTUM_CULLING : osgUtil::CullViewState::NO_CULLING)));
            break;

        case 'P' :
            sceneView->setPrioritizeTextures(!sceneView->getPrioritizeTextures());
            if (sceneView->getPrioritizeTextures())
            {
                osg::notify(osg::NOTICE) << "Prioritize textures switched on   "<< std::endl;
            }
            else
            {
                osg::notify(osg::NOTICE) << "Prioritize textures switched off  "<< std::endl;
            }
            break;

        case '?' :
        case 'h' :
            help(osg::notify(osg::NOTICE));
            break;

        case 'i' :
        case 'r' :
        {
            osg::notify(osg::NOTICE) << "***** Intersecting **************"<< std::endl;

            osg::Vec3 near_point,far_point;
            if (!sceneView->projectWindowXYIntoObject(x,_wh-y,near_point,far_point))
            {
                osg::notify(osg::NOTICE) << "Failed to calculate intersection ray."<< std::endl;
                return;
            }

            osg::ref_ptr<osg::LineSegment> LineSegment = new osg::LineSegment;
            LineSegment->set(near_point,far_point);
            osg::notify(osg::NOTICE) << "start("<<LineSegment->start()<<")  end("<<LineSegment->end()<<")"<< std::endl;

            osgUtil::IntersectVisitor iv;
            iv.addLineSegment(LineSegment.get());

            float startTime = clockSeconds();

            sceneView->getSceneData()->accept(iv);

            float endTime = clockSeconds();

            osg::notify(osg::NOTICE) << "Time for interesection = "<<(endTime-startTime)*1000<<"ms"<< std::endl;

            if (iv.hits())
            {
                osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(LineSegment.get());
                for(osgUtil::IntersectVisitor::HitList::iterator hitr=hitList.begin();
                    hitr!=hitList.end();
                    ++hitr)
                {
                    osg::Vec3 ip = hitr->_intersectPoint;
                    osg::Vec3 in = hitr->_intersectNormal;
                    osg::Geode* geode = hitr->_geode;
                    osg::notify(osg::NOTICE) << "  Itersection Point ("<<ip<<") Normal ("<<in<<")"<< std::endl;
                    if (hitr->_matrix)
                    {
                        osg::Vec3 ipEye = ip*(*(hitr->_matrix));
                        osg::Vec3 inEye = (in+ip)*(*(hitr->_matrix))-ipEye;
                        inEye.normalize();
                        if (geode) osg::notify(osg::NOTICE) << "Geode '"<<geode->getName()<< std::endl;
                        osg::notify(osg::NOTICE) << "  Eye Itersection Point ("<<ipEye<<") Normal ("<<inEye<<")"<< std::endl;

                    }
                    if (key=='r' && geode)
                    {
                        // remove geoset..
                        osg::GeoSet* gset = hitr->_geoset;
                        osg::notify(osg::NOTICE) << "  geoset ("<<gset<<") "<<geode->removeDrawable(gset)<<")"<< std::endl;
                    }

                }

            }

            osg::notify(osg::NOTICE) << std::endl << std::endl;
        }
        break;

        case 27 :                // Escape
            exit(0);
            break;
    }
}


void Viewer::help(std::ostream& fout)
{

    fout << std::endl
        <<"Scene Graph Viewer (sgv) keyboard bindings:"<< std::endl
        << std::endl
        <<"1     Select the trackball camera manipulator."<< std::endl
        <<"      Left mouse button - rotate,"<< std::endl
        <<"      Middle (or Left & Right) mouse button - pan,"<< std::endl
        <<"      Right mouse button - zoom."<< std::endl
        <<"2     Select the flight camera manipulator."<< std::endl
        <<"      Left mouse button - speed up,"<< std::endl
        <<"      Middle (or Left & Right) mouse button - stop,"<< std::endl
        <<"      Right mouse button - slow down, reverse."<< std::endl
        <<"      Move mouse left to roll left, right to roll right."<< std::endl
        <<"      Move mouse back (down) to pitch nose up, forward to pitch down."<< std::endl
        <<"      In mode Q, the default, selected by pressing 'q'"<< std::endl
        <<"        The flight path is yawed automatically into the turn to"<< std::endl
        <<"        produce a similar effect as flying an aircaft."<< std::endl
        <<"      In mode A, selected by pressing 'a'"<< std::endl
        <<"        The flight path is not yawed automatically into the turn,"<< std::endl
        <<"        producing a similar effect as space/marine flight."<< std::endl
        <<"3     Select the drive camera manipulator."<< std::endl
        <<"      In mode Q, the default, selected by pressing 'q'"<< std::endl
        <<"        Move mouse left to turn left, right to turn right."<< std::endl
        <<"        Move mouse back (down) to reverse, forward to drive forward."<< std::endl
        <<"      In mode A, selected by pressing 'a'"<< std::endl
        <<"        Move mouse left to turn left, right to turn right."<< std::endl
        <<"        Left mouse button - speed up,"<< std::endl
        <<"        Middle (or Left & Right) mouse button - stop,"<< std::endl
        <<"        Right mouse button - slow down, reverse."<< std::endl
        << std::endl
        <<"+     Half the frame delay which speeds up the frame rate on Linux and Windows."<< std::endl
        <<"-     Double the frame delay and therefore reduce the frame rate on Linux"<< std::endl
        <<"      and Windows."<< std::endl
        << std::endl
        <<"/     Divide the Level-Of-Detail (LOD) bias by 1.5, to encourage the"<< std::endl
        <<"      selection of more complex LOD children."<< std::endl
        <<"*     Multiple the Level-of-Detail (LOD) bias by 1.5, to encourage the"<< std::endl
        <<"      selection of less complex LOD children."<< std::endl
        << std::endl
        <<"c     Toggle Small Feature Culling on or off."<< std::endl
        <<"C     Toggle View Frustum Culling on or off."<< std::endl
        <<"d     Toggle use of OpenGL's display lists."<< std::endl
        <<"b     Toggle OpenGL's backface culling."<< std::endl
        <<"t     Toggle OpenGL texturing on or off."<< std::endl
        <<"T     Toggle OpenGL two-sided lighting on or off."<< std::endl
        <<"l     Toggle OpenGL lighting on or off."<< std::endl
        <<"L     Toggle SceneView lighting mode between HEADLIGHT, SKY_LIGHT"<< std::endl
        <<"      and NO_SCENEVIEW_LIGHT."<< std::endl
        <<"s     Toggle OpenGL shade model between flat and smooth shading."<< std::endl
        <<"S     Apply osgUtil::SmoothingVisitor to the scene."<< std::endl
        <<"w     Toggle OpenGL polygon mode between solid, wireframe and points modes."<< std::endl
        << std::endl
        <<"i     Calculate and report the intersections with the scene under the"<< std::endl
        <<"      current mouse x and mouse y position."<< std::endl
        << std::endl
        <<"r     Calculate and report the intersections with the scene under the"<< std::endl
        <<"      current mouse x and mouse y position and delete the nearest"<< std::endl
        <<"      interesected geoset."<< std::endl
        << std::endl
        <<"7     Set the background color to black."<< std::endl
        <<"8     Set the background color to blue."<< std::endl
        <<"9     Set the background color to white."<< std::endl
        << std::endl
        <<"p     Print frame rate statistics on each frame."<< std::endl
        <<"o     Output the loaded scene to 'saved_model.osg'."<< std::endl
        <<"?/h   Print out sgv's keyboard bindings."<< std::endl
        <<"f     Toggle between fullscreen and the previous window size. Note, GLUT"<< std::endl
        <<"      fullscreen works properly on Windows and Irix, but on Linux"<< std::endl
        <<"      it just maximizes the window and leaves the window's borders."<< std::endl
        <<"Space Reset scene to the default view."<< std::endl
        <<"Esc   Exit sgv."<< std::endl;
}


osg::Timer_t Viewer::clockTick()
{
    return _timer.tick();
}


osg::Timer_t Viewer::frameTick()
{
    return _frameTick;
}


// update time from the current frame update and the previous one.
osg::Timer_t Viewer::updateFrameTick()
{
    _lastFrameTick = _frameTick;
    _frameTick = _timer.tick();
    return _frameTick;
}


bool Viewer::run()
{

    // Reset the views of all of SceneViews
    osg::ref_ptr<GLUTEventAdapter> ea = new GLUTEventAdapter;

    for(ViewportList::iterator itr=_viewportList.begin();
        itr!=_viewportList.end();
        ++itr)
    {
        itr->_cameraManipulator->home(*ea,*this);
    }

    updateFrameTick();
    return Window::run();
}


void Viewer::addViewport(osgUtil::SceneView* sv,
                         float x, float y, float width, float height) 
{ 
    ViewportDef def;
    def.sceneView   = sv;
    def.viewport[0] = x;
    def.viewport[1] = y;
    def.viewport[2] = width;
    def.viewport[3] = height;
    _viewportList.push_back(def);
}


/**
  * Adds a default SceneView referring to the passed scene graph root.
  */
void Viewer::addViewport(osg::Node* rootnode,
                         float x, float y, float width, float height) 
{
    osgUtil::SceneView *sceneView = new osgUtil::SceneView(_displaySettings.get());
    sceneView->setDefaults();
    sceneView->setSceneData(rootnode);

    addViewport( sceneView, x, y, width, height );
}

void Viewer::init(osg::Node* rootnode)
{
    osg::notify(osg::WARN)<<"Warning - call to Viewer::init(osg::Node*) which is a deprecated method."<< std::endl;
    osg::notify(osg::WARN)<<"          This should be replaced with Viewer::addViewport(osg::Node*)."<< std::endl;
    osg::notify(osg::WARN)<<"          Automatically mapping init to addViewport."<< std::endl;
    addViewport(rootnode);
}



//////////////////////////////////////////////////////////////////////

GLuint makeRasterFont(void)
{ // GWM creates a set of display lists which may be used to render a character string on the screen
        // data from GWM's reading of the Windows ASCII_FIXED_FONT.
    GLubyte rasters[][12] = { // ascii symbols 32-127, small font
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x14, 0x14, 0x00},
        {0x00, 0x00, 0x28, 0x28, 0x7e, 0x14, 0x14, 0x14, 0x3f, 0x0a, 0x0a, 0x00},
        {0x00, 0x00, 0x08, 0x1c, 0x22, 0x02, 0x1c, 0x20, 0x22, 0x1c, 0x08, 0x00},
        {0x00, 0x00, 0x02, 0x45, 0x22, 0x10, 0x08, 0x04, 0x22, 0x51, 0x20, 0x00},
        {0x00, 0x00, 0x3b, 0x44, 0x4a, 0x49, 0x30, 0x10, 0x20, 0x20, 0x18, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x00},
        {0x04, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x00},
        {0x10, 0x08, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08, 0x10, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x36, 0x1c, 0x7f, 0x1c, 0x36, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x08, 0x08, 0x08, 0x7f, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00},
        {0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x38, 0x08, 0x00},
        {0x00, 0x00, 0x3e, 0x20, 0x10, 0x08, 0x04, 0x02, 0x02, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x02, 0x02, 0x0c, 0x02, 0x02, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x0e, 0x04, 0x3e, 0x24, 0x14, 0x14, 0x0c, 0x0c, 0x04, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x02, 0x02, 0x3c, 0x20, 0x20, 0x20, 0x3e, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x3c, 0x20, 0x20, 0x10, 0x0c, 0x00},
        {0x00, 0x00, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, 0x22, 0x3e, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x18, 0x04, 0x02, 0x02, 0x1e, 0x22, 0x22, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x08, 0x00, 0x08, 0x08, 0x04, 0x02, 0x02, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x1c, 0x20, 0x4e, 0x55, 0x55, 0x55, 0x4d, 0x21, 0x1e, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x3e, 0x22, 0x14, 0x14, 0x08, 0x08, 0x18, 0x00},
        {0x00, 0x00, 0x7e, 0x21, 0x21, 0x21, 0x3e, 0x21, 0x21, 0x21, 0x7e, 0x00},
        {0x00, 0x00, 0x1e, 0x21, 0x40, 0x40, 0x40, 0x40, 0x40, 0x21, 0x1e, 0x00},
        {0x00, 0x00, 0x7c, 0x22, 0x21, 0x21, 0x21, 0x21, 0x21, 0x22, 0x7c, 0x00},
        {0x00, 0x00, 0x7f, 0x21, 0x20, 0x24, 0x3c, 0x24, 0x20, 0x21, 0x7f, 0x00},
        {0x00, 0x00, 0x78, 0x20, 0x20, 0x24, 0x3c, 0x24, 0x20, 0x21, 0x7f, 0x00},
        {0x00, 0x00, 0x1e, 0x21, 0x41, 0x47, 0x40, 0x40, 0x40, 0x21, 0x1e, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x22, 0x22, 0x3e, 0x22, 0x22, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00},
        {0x00, 0x00, 0x38, 0x44, 0x44, 0x04, 0x04, 0x04, 0x04, 0x04, 0x1e, 0x00},
        {0x00, 0x00, 0x73, 0x22, 0x24, 0x38, 0x28, 0x24, 0x24, 0x22, 0x73, 0x00},
        {0x00, 0x00, 0x7f, 0x11, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7c, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x22, 0x2a, 0x2a, 0x36, 0x36, 0x22, 0x63, 0x00},
        {0x00, 0x00, 0x72, 0x22, 0x26, 0x26, 0x2a, 0x32, 0x32, 0x22, 0x67, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x41, 0x41, 0x41, 0x41, 0x41, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x78, 0x20, 0x20, 0x20, 0x3e, 0x21, 0x21, 0x21, 0x7e, 0x00},
        {0x00, 0x1b, 0x1c, 0x22, 0x41, 0x41, 0x41, 0x41, 0x41, 0x22, 0x1c, 0x00},
        {0x00, 0x00, 0x73, 0x22, 0x24, 0x24, 0x3e, 0x21, 0x21, 0x21, 0x7e, 0x00},
        {0x00, 0x00, 0x3e, 0x41, 0x01, 0x01, 0x3e, 0x40, 0x40, 0x41, 0x3e, 0x00},
        {0x00, 0x00, 0x1c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x49, 0x7f, 0x00},
        {0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x08, 0x08, 0x14, 0x14, 0x14, 0x22, 0x22, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x14, 0x14, 0x2a, 0x2a, 0x2a, 0x22, 0x22, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x14, 0x14, 0x08, 0x14, 0x14, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x1c, 0x08, 0x08, 0x08, 0x14, 0x14, 0x22, 0x22, 0x77, 0x00},
        {0x00, 0x00, 0x7f, 0x21, 0x10, 0x10, 0x08, 0x04, 0x04, 0x42, 0x7f, 0x00},
        {0x1c, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1c, 0x00},
        {0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00},
        {0x1c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x1c, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x14, 0x08},
        {0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x00},
        {0x00, 0x00, 0x3d, 0x42, 0x42, 0x3e, 0x02, 0x3c, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x7e, 0x21, 0x21, 0x21, 0x21, 0x3e, 0x20, 0x20, 0x60, 0x00},
        {0x00, 0x00, 0x3e, 0x41, 0x40, 0x40, 0x41, 0x3e, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x3f, 0x42, 0x42, 0x42, 0x42, 0x3e, 0x02, 0x02, 0x06, 0x00},
        {0x00, 0x00, 0x3e, 0x41, 0x40, 0x7f, 0x41, 0x3e, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x3c, 0x10, 0x10, 0x10, 0x10, 0x3c, 0x10, 0x10, 0x0c, 0x00},
        {0x3c, 0x02, 0x02, 0x3e, 0x42, 0x42, 0x42, 0x3f, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x22, 0x22, 0x32, 0x2c, 0x20, 0x20, 0x60, 0x00},
        {0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00, 0x08, 0x00},
        {0x38, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x3c, 0x00, 0x00, 0x04, 0x00},
        {0x00, 0x00, 0x63, 0x24, 0x38, 0x28, 0x24, 0x26, 0x20, 0x20, 0x60, 0x00},
        {0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18, 0x00},
        {0x00, 0x00, 0x6b, 0x2a, 0x2a, 0x2a, 0x2a, 0x74, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x22, 0x22, 0x32, 0x6c, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x3e, 0x41, 0x41, 0x41, 0x41, 0x3e, 0x00, 0x00, 0x00, 0x00},
        {0x70, 0x20, 0x3e, 0x21, 0x21, 0x21, 0x21, 0x7e, 0x00, 0x00, 0x00, 0x00},
        {0x07, 0x02, 0x3e, 0x42, 0x42, 0x42, 0x42, 0x3f, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x7c, 0x10, 0x10, 0x10, 0x19, 0x76, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x3e, 0x41, 0x06, 0x38, 0x41, 0x3e, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x0c, 0x12, 0x10, 0x10, 0x10, 0x3c, 0x10, 0x10, 0x00, 0x00},
        {0x00, 0x00, 0x1b, 0x26, 0x22, 0x22, 0x22, 0x66, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x08, 0x14, 0x14, 0x22, 0x22, 0x77, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x14, 0x14, 0x2a, 0x2a, 0x22, 0x77, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x77, 0x22, 0x1c, 0x1c, 0x22, 0x77, 0x00, 0x00, 0x00, 0x00},
        {0x30, 0x08, 0x08, 0x14, 0x14, 0x22, 0x22, 0x77, 0x00, 0x00, 0x00, 0x00},
        {0x00, 0x00, 0x7e, 0x22, 0x10, 0x08, 0x44, 0x7e, 0x00, 0x00, 0x00, 0x00},
        {0x06, 0x08, 0x08, 0x08, 0x08, 0x30, 0x08, 0x08, 0x08, 0x08, 0x06, 0x00},
        {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08},
        {0x30, 0x08, 0x08, 0x08, 0x08, 0x06, 0x08, 0x08, 0x08, 0x08, 0x30, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x49, 0x31, 0x00, 0x00},
        {0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00}
    };
    // the remaining lines of this routine are similar to code developed and published in the
    // OPENGL big red book.  However I have modified the code slightly, and
    // SGI are not responsible for any errors, omissions etc.
    static GLuint fontOffset=0; // first display list
    if (!fontOffset) { // then make the raster fonts
        GLuint i;
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

        fontOffset = glGenLists (128);
        for (i = 32; i < 127; i++) {
            glNewList(i+fontOffset, GL_COMPILE);
            glBitmap(8, 12, 0.0, 2.0, 10.0, 0.0, rasters[i-32]);
            glEndList();
        }
    }
    return fontOffset;
}

void displaytext(int x, int y, char *s)
{ // GWM July 2001 statistics text display at xy text S
    GLuint fontOffset=makeRasterFont(); // first display list
    glRasterPos2i(x,y);
    glListBase(fontOffset);
    glCallLists(strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s);
    glListBase(0);
    //    glPopAttrib ();
}
/*
void writePrims( const int ypos, osg::Statistics& stats)
{
    char clin[100]; // buffer to print
    char ctmp[12];
    int i; // a counter
    static char *prtypes[]={"Total", 
            "   Pt", "   Ln", " Lstr", " LSTf", " Llop", // 1- 5
            " Tris", " TStr", " TSfl", " TFan", " TFnf", // 6-10
            " Quad", " QStr", " Pols", "", "", // 11-15
            "", "", "", "", ""};
    glColor3f(.9f,.9f,0.0f);

    sprintf(clin,"%d Prims %d Matxs %d Gsets %d nlts %d bins %d imps", 
    stats.nprims, stats.nummat, stats.numOpaque, stats.nlights, stats.nbins, stats.nimpostor);
    displaytext(0,ypos,clin);
    strcpy(clin,"           ");
    for (i=0; i<15; i++) {
        if (i==0 || stats.primtypes[i]) {
            strcat(clin, prtypes[i]);
        }
    }
    displaytext(0,ypos-12,clin);
    strcpy(clin,"GSet type: ");
    for (i=0; i<15; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primtypes[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-24,clin);
    strcpy(clin,"Prims:     ");
    for (i=0; i<15; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.numprimtypes[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-36,clin);
    strcpy(clin,"Triangles: ");
    for (i=0; i<15; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primlens[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-48,clin);
    strcpy(clin,"Vertices:  ");
    for (i=0; i<15; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primverts[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-60,clin);
}
*/
int writePrims( const int ypos, osg::Statistics& stats)
{
    char clin[100]; // buffer to print
    char ctmp[12];
    int i; // a counter
    int npix=0; // offset from ypos
    char intro[12]; // start of first line
    static char *prtypes[]={"Total", 
            "   Pt", "   Ln", " Lstr", " LSTf", " Llop", // 1- 5
            " Tris", " TStr", " TSfl", " TFan", " TFnf", // 6-10
            " Quad", " QStr", " Pols", "", "", // 11-15
            "", "", "", "", ""};
    glColor3f(.9f,.9f,0.0f);

    if (stats.depth==1) sprintf(intro,"==> Bin %2d", stats._binNo);
    else         sprintf(intro,"          ");
    sprintf(clin,"%s %d Prims %d Matxs %d Gsets %d nlts %d bins %d imps", 
        intro ,stats.nprims, stats.nummat, stats.numOpaque, stats.nlights, stats.nbins, stats.nimpostor);
    displaytext(0,ypos-npix,clin);
    npix+=12;
    strcpy(clin,"           ");
    for (i=0; i<=osg::Statistics::POLYGON; i++) {
        if (i==0 || stats.primtypes[i]) {
            strcat(clin, prtypes[i]);
        }
    }
    displaytext(0,ypos-npix,clin);
    npix+=12;
    strcpy(clin,"GSet type: ");
    for (i=0; i<=osg::Statistics::POLYGON; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primtypes[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-npix,clin);
    npix+=12;
    strcpy(clin,"Prims:     ");
    for (i=0; i<=osg::Statistics::POLYGON; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.numprimtypes[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-npix,clin);
    npix+=12;
    strcpy(clin,"Triangles: ");
    for (i=0; i<=osg::Statistics::POLYGON; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primlens[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-npix,clin);
    npix+=12;
    strcpy(clin,"Vertices:  ");
    for (i=0; i<=osg::Statistics::POLYGON; i++) {
        if (stats.primtypes[i]) {
            sprintf(ctmp,"%5d", stats.primverts[i]);
            strcat(clin, ctmp);
        }
    }
    displaytext(0,ypos-npix,clin);
    npix+=12;
    if (stats.stattype!=osg::Statistics::STAT_PRIMSPERBIN) {
    }
    return npix;
}