source: trunk/src/testing/app/volvis/vFPSText.cpp @ 4

/********************************************************************************
 * Volatile - Volume Visualization Software for SAGE
 * Copyright (C) 2004 Electronic Visualization Laboratory,
 * University of Illinois at Chicago
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following disclaimer
 *    in the documentation and/or other materials provided with the distribution.
 *  * Neither the name of the University of Illinois at Chicago nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Direct questions, comments etc about Volatile to www.evl.uic.edu/cavern/forum
 *********************************************************************************/

#include <stdio.h>
#include "vFPSText.h"
#include "global.h"
GLvoid
  renderBitmapString( char *string )
  {
      int i;
      int len = (int) strlen(string);
      for (i = 0; i < len; i++) {
          glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
      }
  }

  GLvoid
  renderStrokeString( void *font, char *string )
  {
      int i;
      int len = (int) strlen(string);
      for (i = 0; i < len; i++) {
          glutStrokeCharacter(font, string[i]);
      }
  }

CFrameTimer::CFrameTimer() {
  #ifdef WIN32
        LARGE_INTEGER num;
        //get current performance-counter frequency, in counts per second
        QueryPerformanceFrequency(&num);
        timerResolution = (double)num.HighPart*4294967296.0;
        timerResolution += (double)num.LowPart;
        timerResolution=1.0/timerResolution; //get time for 1 count
        QueryPerformanceCounter(&last); //store current counter as last

  #endif

#if defined(linux) || defined(__APPLE__)
        //struct timeval _tstart;
        //struct timezone tz;
        gettimeofday(&_tstart, &tz);
#endif

        elapsedTime=0.0;
        frameLocation=0;
        framesProcessed=0;

}

void CFrameTimer::pingFrameCounter(){
#ifdef WIN32
        LARGE_INTEGER t;
        double elapsed;

        QueryPerformanceCounter(&t); //get current counter
        //get elapsed = current counter - last counter
        elapsed=((double)t.HighPart-(double)last.HighPart)*4294967296.0;
        elapsed+=(double)t.LowPart-(double)last.LowPart;
        elapsed *= timerResolution;
        //update last counter
        last.HighPart=t.HighPart;
        last.LowPart=t.LowPart;
#endif

#if defined(linux) || defined(__APPLE__)
        struct timeval _tend;
        gettimeofday(&_tend,&tz);
        double t1, t2;
        t1 =  (double)_tstart.tv_sec + (double)_tstart.tv_usec/(1000*1000);
        t2 =  (double)_tend.tv_sec + (double)_tend.tv_usec/(1000*1000);
        //return t2-t1;
        double elapsed;
        elapsed = t2 - t1;
        _tstart = _tend;
#endif

        frameTimes[frameLocation]= elapsed; //store elapsed
        elapsedTime += frameTimes[frameLocation]; //add to the total elapsed time
        frameLocation = (frameLocation+1)%FRAME_HISTORY; //next index
        framesProcessed++;
}

float CFrameTimer::getFPS(){
        int top=(FRAME_HISTORY>framesProcessed)?framesProcessed:FRAME_HISTORY;

        double total=0.0f;
        for(int ii=0;ii<top;ii++)
                total+=frameTimes[ii];
        total/=(float)FRAME_HISTORY; //no of secs per frame
        total=1.0f/total; //get fps
        return (float)total;
}

vText::vText(const char* txt) : vPrimitive() {
        strcpy(myText,txt);
}

void vText::init() {
}

void vText::draw() {
        glPushMatrix();
        glRasterPos3f(xform.trans[0],xform.trans[1],xform.trans[2]);
        if (selected)
                glColor3f(0.0f,0.5f,0.5f);
        else
                glColor3f(1.0f,1.0f,1.0f);
        //glScalef(xform.scale,xform.scale,xform.scale);
        //glScalef(0.5, 0.5, 0.5);
        //renderStrokeString(myText);
        renderBitmapString(myText);
        glPopMatrix();
}

void vFPSText::init() {
        xform.trans[0] = -6.0f;
        xform.trans[1] = -5.0f;
        xform.trans[2] = 0.0f;
        vText::init();
        timer = new CFrameTimer();
}

void vFPSText::draw() {
        timer->pingFrameCounter();
        if (global.ui.printFPS) {
                sprintf(myText,"FPS %f",timer->getFPS());
                vText::draw();
        }
}

void vVolText::init() {
        xform.trans[0] = 1.0f;
        xform.trans[1] = -3.0f;
        xform.trans[2] = 0.0f;
        vText::init();
}

void vVolText::draw() {
        sprintf(myText,"(X,Y,Z):(%d,%d,%d) Vox:%d",global.volume->probeX, global.volume->probeY,
                        global.volume->probeZ, global.volume->probeValue);
        vText::draw();
}