timeclock.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/
#ifndef LILITH_TIMECLOCK_INCLUDED
#define LILITH_TIMECLOCK_INCLUDED

#include <time.h>
#include "../grinliz/gltypes.h"
#include "../grinliz/glcolor.h"
#include "../grinliz/glvector.h"
#include "worlddefine.h"

namespace lilith3d
{

class Texture;

struct SunMoon
{
        enum {
                SUNRISE, DAYTIME, SUNSET, NIGHT
        };

        bool            sun;                                    
        grinliz::Vector3F       vector;                 
        grinliz::Vector4F       vector4;                
        grinliz::Color3F ambientColorH;         
        grinliz::Color4F ambientColorH4;        
        grinliz::Color3F diffuseColorH;         
        grinliz::Color4F diffuseColorH4;        
        grinliz::Color3F ambientColorL;         
        grinliz::Color3F diffuseColorL;         
        grinliz::Color4F ambientColorL4;        
        grinliz::Color4F diffuseColorL4;        
        grinliz::Color3F rawAmbientColor;       
        grinliz::Color3F rawDiffuseColor;       
        float           skyBlend;                               
        int                     primarySky;                             
        int                     secondarySky;                   
        grinliz::Color3F        skyColor;               
        const Texture* primarySkydomeTex;               
        const Texture* secondarySkydomeTex;             
};


class TimeClock
{
  public:
        TimeClock( U32 msecPerDay, U32 msecStart );
        ~TimeClock()    {}

        // --- Frames --- //

        U32 CurrentFrame()                                              {       return frameCount; }

        // Tell a clock when "now" is. Called only by the lilith engine.
        void SetFrameStart();
        // Tell the clock that a frame was draw. Again called only by the engine.
        void SetFrameDrawn();

        float Fps()     {       return fps; }
        float FastFps() { return shortFps; }

        float TotalFPS();

        // --- Speed Based Computation --- //

        float CalcVelocity( float vel ) {       return float( msecToLast ) * vel / 1000.0f; }

        float CalcChange( float value, float velocity, float minVal, float maxVal )     
        {       
                GLASSERT( maxVal >= minVal );

                value = value + CalcVelocity( velocity );
                return grinliz::Clamp( value, minVal, maxVal );
        }
        

        // --- Time elapsed --- //

        U32     Msec()                                          {       return msec;    }

        float HoursElapsed()                    {       return float( msec + msecStart ) * 24.0f / float( msecPerDay ); }

        void CalcCalendarTime( U32* days, U32* hours, U32* minutes, U32* seconds );


        // --- The sun and moon -- //

        void ToggleSun()                                {       ++holdSun;
                                                                                if ( holdSun == HOLD_COUNT ) holdSun = 0; 
                                                                        }

        const SunMoon& GetSunMoon()     {       return sunMoon; }

  private:
        struct SkyState
        {
                float   hour;
                int             state;
        };

        struct ColorState
        {
                float           hour;
                grinliz::Color3F        color;
        };

        U32 msecPerDay;
        U32 msecStart;


        // Called once the sun/moon vector is computed.
        void FillSunMoonStruct();

        static TimeClock* instance;

        U32 frameCount;
        U32 msec;                       // clock ticks

        enum { HOLD_NONE, HOLD_MIDDAY, HOLD_SUNRISE, HOLD_COUNT };
        int holdSun;

        SunMoon sunMoon;

        // For long sample fps:
        U32 longStart;
        U32 fpsFrame;
        float fps;

        // For 200ms fps:
        U32 shortStart;
        U32 shortFpsFrame;
        float shortFps;
        U32 startupMsec;

        // For short sample
        U32 msecToLast;
        U32 lastStart;
};
};

#endif

---