Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

vuHWTimer.cpp

Go to the documentation of this file.
00001 #include "vuHWTimer.h"
00002 
00003 #if defined(WIN32)
00004 
00005     vuHWTimer::vuHWTimer()
00006     {
00007         LARGE_INTEGER freq;
00008 
00009         if (QueryPerformanceFrequency(&freq))
00010         {
00011             m_IsSupported = true;
00012             m_FloatFreq   = (float)freq.QuadPart;
00013             m_DoubleFreq  = (double)freq.QuadPart;
00014         }
00015         else
00016         {
00017             m_IsSupported = false;
00018             m_FloatFreq  = 1.0f;
00019             m_DoubleFreq = 1.0;
00020         }
00021     }
00022 
00023     vuHWTimer::vuHWTimer(const vuHWTimer& t)
00024     {
00025         m_LastCount   = t.m_LastCount;
00026         m_FloatFreq   = t.m_FloatFreq;
00027         m_DoubleFreq  = t.m_DoubleFreq;
00028         m_IsSupported = t.m_IsSupported;
00029     }
00030 
00031     vuHWTimer::~vuHWTimer()
00032     {
00033     }
00034 
00035     vuHWTimer& vuHWTimer::operator=(const vuHWTimer& rhs)
00036     {
00037         if (this != &rhs)
00038         {
00039             m_LastCount   = rhs.m_LastCount;
00040             m_FloatFreq   = rhs.m_FloatFreq;
00041             m_DoubleFreq  = rhs.m_DoubleFreq;
00042             m_IsSupported = rhs.m_IsSupported;
00043         }
00044         return *this;
00045     }
00046 
00047     bool vuHWTimer::isSupported(void) const
00048     {
00049         return m_IsSupported;
00050     }
00051 
00052     float vuHWTimer::getElapsedTimeFloat(void)
00053     {
00054         LARGE_INTEGER count;
00055         float time;
00056 
00057         QueryPerformanceCounter(&count);
00058         time = (float)(count.QuadPart - m_LastCount.QuadPart)/m_FloatFreq;
00059         m_LastCount = count;
00060 
00061         return time;
00062     }
00063 
00064     double vuHWTimer::getElapsedTimeDouble(void)
00065     {
00066         LARGE_INTEGER count;
00067         double time;
00068 
00069         QueryPerformanceCounter(&count);
00070         time = (double)(count.QuadPart - m_LastCount.QuadPart)/m_DoubleFreq;
00071         m_LastCount = count;
00072 
00073         return time;
00074     }
00075 
00076     void vuHWTimer::sleepFloat(float s)
00077     {
00078         LARGE_INTEGER count;
00079         float time = -1.0f;
00080 
00081         if (s < 0.0f)
00082             return;
00083 
00084         while(time < s)
00085         {
00086             QueryPerformanceCounter(&count);
00087             time = (float)(count.QuadPart - m_LastCount.QuadPart)/m_FloatFreq;
00088         }
00089         m_LastCount = count;
00090 
00091         return;
00092     }
00093 
00094     void vuHWTimer::sleepDouble(double s)
00095     {
00096         LARGE_INTEGER count;
00097         double time = -1.0f;
00098 
00099         if (s < 0.0f)
00100             return;
00101 
00102         while(time < s)
00103         {
00104             QueryPerformanceCounter(&count);
00105             time = (double)(count.QuadPart - m_LastCount.QuadPart)/m_DoubleFreq;
00106         }
00107         m_LastCount = count;
00108 
00109         return;
00110     }
00111 
00112 #else
00113 
00114 #define TIMEVALDIFFFLOAT(t1, t2) (((((float)(t1.tv_sec-t2.tv_sec))*1000000.0f) + ((float)(t1.tv_usec-t2.tv_usec)))/1000000.0f)
00115 #define TIMEVALDIFFDOUBLE(t1, t2)                            \
00116           (((((double)(t1.tv_sec-t2.tv_sec))*1000000.0) +     \
00117              ((double)(t1.tv_usec-t2.tv_usec)))/1000000.0)
00118 
00119     vuHWTimer::vuHWTimer()
00120     {
00121         struct timeval tv;
00122 
00123         m_IsSupported = (gettimeofday(&tv, 0) == 0);
00124     }
00125 
00126     vuHWTimer::vuHWTimer(const vuHWTimer& t)
00127     {
00128         m_LastCount.tv_sec   = t.m_LastCount.tv_sec;
00129         m_LastCount.tv_usec  = t.m_LastCount.tv_usec;
00130         m_IsSupported        = t.m_IsSupported;
00131     }
00132 
00133     vuHWTimer::~vuHWTimer()
00134     {
00135     }
00136 
00137     vuHWTimer& vuHWTimer::operator=(const vuHWTimer& rhs)
00138     {
00139         if (this != &rhs)
00140         {
00141             m_LastCount.tv_sec   = rhs.m_LastCount.tv_sec;
00142             m_LastCount.tv_usec  = rhs.m_LastCount.tv_usec;
00143             m_IsSupported        = rhs.m_IsSupported;
00144         }
00145         return *this;
00146     }
00147 
00148     bool vuHWTimer::isSupported(void) const
00149     {
00150         return m_IsSupported;
00151     }
00152 
00153     float vuHWTimer::getElapsedTimeFloat(void)
00154     {
00155         struct timeval count;
00156         float time;
00157 
00158         gettimeofday(&count, 0);
00159         time = TIMEVALDIFFFLOAT(count, m_LastCount);
00160         m_LastCount.tv_sec  = count.tv_sec;
00161         m_LastCount.tv_usec = count.tv_usec;
00162 
00163         return time;
00164     }
00165 
00166     double vuHWTimer::getElapsedTimeDouble(void)
00167     {
00168         struct timeval count;
00169         double time;
00170 
00171         gettimeofday(&count, 0);
00172         time = TIMEVALDIFFDOUBLE(count, m_LastCount);
00173         m_LastCount.tv_sec  = count.tv_sec;
00174         m_LastCount.tv_usec = count.tv_usec;
00175 
00176         return time;
00177     }
00178 
00179     void vuHWTimer::sleepFloat(float s)
00180     {
00181         struct timeval count;
00182         float time = -1.0f;
00183 
00184         if (s < 0.0f)
00185             return;
00186 
00187         while(time < s)
00188         {
00189             gettimeofday(&count, 0);
00190             time = TIMEVALDIFFFLOAT(count, m_LastCount);
00191         }
00192         m_LastCount.tv_sec  = count.tv_sec;
00193         m_LastCount.tv_usec = count.tv_usec;
00194 
00195         return;
00196     }
00197 
00198     void vuHWTimer::sleepDouble(double s)
00199     {
00200         struct timeval count;
00201         double time = -1.0f;
00202 
00203         if (s < 0.0f)
00204             return;
00205 
00206         while(time < s)
00207         {
00208             gettimeofday(&count, 0);
00209             time = TIMEVALDIFFDOUBLE(count, m_LastCount);
00210         }
00211         m_LastCount.tv_sec  = count.tv_sec;
00212         m_LastCount.tv_usec = count.tv_usec;
00213 
00214         return;
00215     }
00216 
00217 #endif

Generated on Wed Dec 15 21:20:34 2004 for vuVolume by  doxygen 1.3.9.1