---

/include/ZE_ZEngine.h

Go to the documentation of this file.

/*******************************************************************************
        This file is Part of the ZEngine Library for 2D game development.
                   Copyright (C) 2002, 2003 James Turk

                     Licensed under a BSD-style license.

    The maintainer of this library is James Turk (james@conceptofzero.net) 
     and the home of this Library is http://www.zengine.sourceforge.net
*******************************************************************************/

//revision on this is so high.. can this be lowered?

#ifndef __ze_zengine_h__
#define __ze_zengine_h__

#include "ZE_Defines.h"
#include "ZE_Utility.h"
#include "ZE_Includes.h"
#include "ZE_ZError.h"
#include "ZE_ZRandGen.h"
#include "VersionInfo.h"

namespace ZE
{

class ZEngine
{
    public:
        static VersionInfo Version;

    private:        
        static ZEngine *sInstance;
        int mWidth;
        int mHeight;
        int mBPP;
        bool mFullscreen;
        bool mInitialized;
        SDL_Surface *mScreen;
        bool mPaused;
        bool mUnpauseOnActive;
        Uint8 mDesiredFramerate;
        Uint32 mNextUpdate;
        Uint32 mLastPause;
        Uint32 mPausedTime;
        Uint32 mLastTime;
        double mSecPerFrame;
        bool mNeedReload;
        bool mActive;
        bool mQuit;
        Uint8 *mKeyIsPressed;
        bool mKeyPress[SDLK_LAST];
        int mMouseX;
        int mMouseY;
        Uint8 mMouseB;
        std::queue<ZError> mErrorQueue;
        ZError mCurError;
        bool mLogAllErrors;
        std::FILE *mErrlog;
        SDL_EventFilter mEventFilter;
        ZRandGen mRandGen;

#ifdef USE_SDL_MIXER 

        int mRate;
        bool mStereo;
#endif 

    //Singleton + Memory Management//

    private:
        ZEngine();

    public:

        static ZEngine* GetInstance();

        static void ReleaseInstance();

    //Initialization//

        void SetupDisplay(int width, int height, int bpp, bool fullscreen);

#ifdef USE_SDL_MIXER

        void SetupSound(int rate, bool stereo);
#endif 

        bool CreateDisplay(std::string title, std::string icon="");

        void CloseDisplay();

        void ToggleFullscreen();

        bool Initialized();

    //Screen Access//

        SDL_Surface *Display();

        void Update();

        void Clear(float red=0.0f, float green=0.0f, float blue=0.0f, float alpha=1.0f);

    //OpenGL Specific Functions//

        void SetGL2D();

    //Timer and Framerate Independent Movement//

        void Delay(Uint32 milliseconds);

        Uint32 GetTime();

        void PauseTimer();

        void UnpauseTimer();

        double GetFrameTime();

        double GetFramerate();

        void SetDesiredFramerate(Uint8 rate);

        Uint8 GetDesiredFramerate();

        bool IsPaused();

    //Event and Input Handling//

        bool IsActive();

        void RequestQuit();

        bool QuitRequested();

        void SetReloadNeed(bool state);

        bool ImagesNeedReload();
        
        void SetKeyRepeatRate(int rate);

        bool KeyIsPressed(SDLKey key);

        bool KeyPress(SDLKey key);

        void HideCursor();

        void ShowCursor();

        int MouseX();

        int MouseY();

        bool LButtonPressed();

        bool RButtonPressed();

        bool MouseInRect(SDL_Rect *rect);

        void CheckEvents();

        void SetEventFilter(SDL_EventFilter filter);

#ifdef USE_PHYSFS

    //Physfs Utilities//

        void InitPhysFS(std::string argv);

        void AddPhysFSDir(std::string dir);

#endif    //USE_PHYSFS

    //Error Logging//
    private:
        void LogError(ZError error);

    public:
        void SetErrorLog(bool logAll, std::string logFile="");

        void ReportError(ZErrorCode code, std::string desc="", std::string file="", unsigned int line=0);

        ZErrorCode GetLastError();

        void WriteLog(std::string str);

        void FlushErrors();

    //Random Number Generation//

        void SeedRandGen(unsigned long seed);

        unsigned int Rand(unsigned int max);

        unsigned long Rand(unsigned long max);

        int Rand(int min, int max);

        long Rand(long min, long max);

        float Rand(float min, float max);

        double Rand(double min, double max);

        double RandDouble();

    //Data Loading + Unloading//

        SDL_Surface* LoadImage(std::string filename);

#ifdef USE_SDL_MIXER

        Mix_Chunk* LoadSound(std::string filename);

        Mix_Music* LoadMusic(std::string filename);
#endif

#ifdef USE_SDL_TTF

        TTF_Font* LoadFont(std::string filename, int size);
#endif 

    //Accessors//

        int Width();

        int Height();

        int BPP();

        bool IsFullscreen();
};

}

#endif //__ze_zengine_h__

---