Finish Project3,Bo Zhang, all the details are written in readme, including a video link.

src/clock.h

@@ -0,0 +1,113 @@
+
+#ifndef __MMC_CLOCK_H__
+#define __MMC_CLOCK_H__
+
+#include "timer.h"
+
+namespace mmc
+{
+
+    /*! \brief High precision clock for timing events. 
+
+      This class is implemented on top of the Timer class.  Usually it is
+      not necessary to use the Timer class directly; instead, use this
+      class. */
+    class Clock
+    {
+    public:
+        /*! Construct a clock. */
+        inline Clock ();
+
+        /*! Reset the clock (0 time elapsed). */
+        inline void reset ();
+
+        /*! Call once per frame to update the internal clock state. */
+        inline void inc ();
+
+        /*! Returns the amount of time (in ms) elapsed between last
+          two calls to \p inc(). */
+        inline long queryInc () const;
+
+        /*! Returns the amount of time (in ms) elapsed since clock creation or
+          reset() was called. */
+        inline long queryTime () const;
+
+        /*! Pause the clock. */
+        inline void pauseToggle ();
+
+    private:
+        Timer *timer_;
+        MMC_TIME_TYPE inc_;
+        MMC_TIME_TYPE curTime_;
+        MMC_TIME_TYPE start_;
+        bool paused_;
+        double invFreq_;
+    };
+
+    //////////////////////////////////////////////////////////////////////
+    //  Implementation.
+    //
+
+    inline
+    Clock::Clock ()
+        : paused_(false)
+    {
+        timer_ = new Timer;
+        invFreq_ = timer_->getInvFreq();
+        timer_->start();
+        reset();
+    }
+
+    void
+    Clock::reset ()
+    {
+        start_ = timer_->queryElapsed();
+        inc_ = curTime_ = 0;
+    }
+
+    void
+    Clock::inc ()
+    {
+        timer_->inc();
+        if (!paused_)
+        {
+            inc_ = timer_->queryInc();
+            curTime_ += inc_;
+        }
+        else
+        {
+            inc_ = 0;
+        }
+    }
+
+    // Converts internal clock increment to long in milliseconds.
+    long
+    Clock::queryInc () const
+    {
+        return (long) (1000.0 * inc_ * invFreq_);
+    }
+
+    // Converts internal clock time to long in milliseconds.
+    long
+    Clock::queryTime () const
+    {
+        return (long) (1000.0 * curTime_ * invFreq_);
+    }
+
+    void
+    Clock::pauseToggle ()
+    {
+        if (paused_)
+        {
+            paused_ = false;
+        }
+        else
+        {
+            paused_ = true;
+            inc_ = 0;
+        }
+    }
+
+} // namespace mmc
+
+#endif // __MMC_CLOCK_H__

src/fps.cpp

@@ -0,0 +1,57 @@
+#include "fps.h"
+#include "clock.h"
+
+using namespace mmc;
+
+FpsTracker::FpsTracker (int smoothSteps)
+	: steps_(smoothSteps), nSnaps_(0)
+{
+	clock_ = new Clock;
+	snaps_ = new long[steps_];
+	memset(snaps_, 0, sizeof(long) * steps_);    
+}
+
+FpsTracker::~FpsTracker ()
+{
+	delete snaps_;
+	delete clock_;
+}
+
+void
+	FpsTracker::timestamp ()
+{
+	clock_->inc();
+	snaps_[nSnaps_ % steps_] = clock_->queryInc();
+	nSnaps_++;
+}
+
+float
+	FpsTracker::fpsAverage () const
+{
+	int count = (nSnaps_ < steps_) ? nSnaps_ : steps_;
+	long sum = 0L;
+	for (int i = 0; i < count; ++i)
+	{
+		sum += snaps_[i];
+	}
+	if (!sum) sum = 1L; // prevent div-by-zero
+	return 1000.0f * count / (float) sum;
+}
+
+float 
+	FpsTracker::fpsInstant () const
+{
+	long inc = clock_->queryInc();
+	if (!inc) inc = 1L; // prevent div-by-zero
+	return 1000.0f / (float) inc;
+}
+
+void
+	FpsTracker::setNumSteps (int smoothSteps)
+{
+	steps_ = smoothSteps;
+	delete snaps_;
+	snaps_ = new long[steps_];
+	memset(snaps_, 0, sizeof(long) * steps_);
+	nSnaps_ = 0;
+}

src/fps.h

@@ -0,0 +1,54 @@
+
+/*! \file fps.h
+  \brief Defines a class for keeping track of frames/sec.
+  \author Eric Chan
+  \date July 2003
+*/
+
+#ifndef __MMC_FPS_H__
+#define __MMC_FPS_H__
+
+#include <vector>
+
+namespace mmc
+{
+    class Clock;
+
+    /*! \brief Utility class for measuring framerate. */
+    class FpsTracker
+    {
+    public:
+        /*! Create a FpsTracker.  \p smoothSteps is the window size
+          over which to average the time measurements. */
+        FpsTracker (int smoothSteps = 4);
+
+        /*! Deallocate a FpsTracker. */
+        ~FpsTracker ();
+
+        /*! Specify the window size \p smoothSteps over which the time
+          measurements will be averaged. */
+        void setNumSteps (int smoothSteps);
+
+        /*! Makes a timestamp (i.e. takes a snapshot); measures
+          time intervals between successful calls.  Usually, you want
+          to call this function once per rendering loop. */
+        void timestamp ();
+
+        /*! Get the average FPS (averaged over \p smoothSteps
+          interval). */
+        float fpsAverage () const;
+
+        /*! Get the instantaneous FPS (estimated from the last frame
+          only). */
+        float fpsInstant () const;
+
+    private:
+        Clock *clock_;
+        int steps_;
+        int nSnaps_;
+        long *snaps_;
+    };
+
+} // namespace mmc
+
+#endif // __MMC_FPS_H__