include/Graphics.h

#ifndef _GRAPHICS_
#define _GRAPHICS_

#include <Level2D.h>
#include <string>
#include <iostream>
#include <sstream>
#include <irrlicht.h>
#include <CustomVertexObject.h>
#include <disableWarnings.h>

namespace sonus
{
        using namespace irr;    

        struct GlobalFunction
        {
                irr::EKEY_CODE  key;
                void                    ( *pfunction )();
        };

        struct GlobalBoolean
        {
                irr::EKEY_CODE  key;
                bool*                   value;
                bool                    setValue;
        };

        struct ChangingValue
        {
                const char*             name;
                int*                    value;
                int                             step;
        };

        struct IncrementalValue
        {
                irr::EKEY_CODE  key;
                int*                    value;
                int                             step;
                int                             min;
                int                             max;
        };


        class Graphics : public irr::IEventReceiver
        {
                
                public:

                        virtual bool Graphics::OnEvent(SEvent event);

                        static bool fullscreen;
                        static int resolutionX;
                        static int resolutionY;

                        static Graphics* getInstance()
                        {
                                if ( instance == NULL )
                                {
                                        instance = new Graphics();
                                }

                                return instance;
                        }

                        ~Graphics();

                        void            initLevel( Level2D* level );

                        void            update( Level2D* level );

                        void            beginRender();

                        void            renderViewports();

                        void            renderConsole();

                        void            renderStatus();

                        void            renderBlend();

                        void            endRender();

                        void            addGlobalFunction( irr::EKEY_CODE irrKey, void ( *pfunction )() );

                        void            addGlobalBoolean( irr::EKEY_CODE irrKey, bool* value, bool setValue );

                        void            addIncrementalValue( irr::EKEY_CODE irrKey, int* value, int min, int max, int step );

                        void            setChangingValue( const char* name, int* value, int step );

                        std::wstringstream                      consoleText;
                        scene::ISceneManager*           smgr;
                        IrrlichtDevice*                         device;
                        video::IVideoDriver*            driver;
                        gui::IGUIEnvironment*           env;
                        gui::IGUIStaticText*            textbox;
                        gui::IGUIStaticText*            status;

                        int                                                     viewportMode;

                        double                                          portalAnimation;
                        bool                                            portalAnimationFinished;
                        int                                                     portalBlend;
                        long                                            portalAnimationStart;

                        Vector2D*                                       transformationVector;
                        double                                          scaleFactor;

                private:

                        void            addBodyToScene( Body2D<Vector2D>* body );

                        Graphics();

                        static Graphics*                        instance;

                        scene::ICameraSceneNode*        camera1;
                        scene::ICameraSceneNode*        camera2;
                        scene::ICameraSceneNode*        camera3;
                        scene::ICameraSceneNode*        camera4;

                        std::wstring                            consoleTextString;
                        CustomVertexObject*                     player;
                        scene::ISceneNode*                      portal;
                        scene::ISceneNode*                      portal2;
                        scene::ISceneNode*                      portal3;
                        scene::ISceneNode*                      portal4;
                        core::rect<s32>                         oldViewPort;

                        float                                           playerRadius;
                        long                                            portalScaleT0;
                        double                                          portalScale;

                        GlobalFunction                          globalFunctions[ 10 ];
                        int                                                     globalFunctionsIndex;

                        GlobalBoolean                           globalBooleans[ 50 ];
                        int                                                     globalBooleansIndex;

                        IncrementalValue                        incrementalValues[ 10 ];
                        int                                                     incrementalValuesIndex;

                        ChangingValue                           changingValue;

                        

        };

}

#endif

---