OgreProfiler.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
/*

    Although the code is original, many of the ideas for the profiler were borrowed from 
"Real-Time In-Game Profiling" by Steve Rabin which can be found in Game Programming
Gems 1.

    This code can easily be adapted to your own non-Ogre project. The only code that is 
Ogre-dependent is in the visualization/logging routines and the use of the Timer class.

    Enjoy!

*/

#ifndef __Profiler_H__
#define __Profiler_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreString.h"
#include "OgreOverlay.h"

#if OGRE_PROFILING == 1
#   if OGRE_COMPILER != OGRE_COMPILER_BORL
#       define OgreProfile( a ) Ogre::Profile _OgreProfileInstance( (a) )
#       define OgreProfileBegin( a ) Ogre::Profiler::getSingleton().beginProfile( (a) )
#       define OgreProfileEnd( a ) Ogre::Profiler::getSingleton().endProfile( (a) )
#   else
#       define OgreProfile( a ) Ogre::Profile _OgreProfileInstance( __FUNC__ )
#       define OgreProfileBegin( a ) Ogre::Profiler::getSingleton().beginProfile( __FUNC__ )
#       define OgreProfileEnd( a ) Ogre::Profiler::getSingleton().endProfile( __FUNC__ )
#   endif
#else
#   define OgreProfile( a )
#   define OgreProfileBegin( a )
#   define OgreProfileEnd( a )
#endif

namespace Ogre {

    class _OgreExport Profile {

        public:
            Profile(const String& profileName);
            ~Profile();

        protected:

            String mName;
            

    };

    class _OgreExport Profiler : public Singleton<Profiler> {

        public:
            Profiler();
            ~Profiler();

            void setTimer(Timer* t);

            Timer* getTimer();

            void beginProfile(const String& profileName);

            void endProfile(const String& profileName);

            void setEnabled(bool enabled);

            bool getEnabled() const;

            void enableProfile(const String& profileName);

            void disableProfile(const String& profileName);

            bool watchForMax(const String& profileName);

            bool watchForMin(const String& profileName);

            bool watchForLimit(const String& profileName, Real limit, bool greaterThan = true);

            void logResults();

            void reset();

            void setUpdateDisplayFrequency(uint freq);

            uint getUpdateDisplayFrequency() const;

            static Profiler& getSingleton(void);
            static Profiler* getSingletonPtr(void);

        protected:

            void initialize();

            void displayResults();

            void processFrameStats();

            void changeEnableState();

            OverlayContainer* createContainer();

            OverlayElement* createTextArea(const String& name, Real width, Real height, Real top, Real left, 
                                       uint fontSize, const String& caption, bool show = true);

            OverlayElement* createPanel(const String& name, Real width, Real height, Real top, Real left, 
                                    const String& materialName, bool show = true);

            struct ProfileInstance {

                String      name;

                String      parent;

                ulong       currTime;

                ulong       accum;

                uint        hierarchicalLvl;
            };

            struct ProfileFrame {
                
                String  name;

                ulong   frameTime;

                uint    calls;

                uint    hierarchicalLvl;

            };
            
            struct ProfileHistory {

                String  name;

                Real    currentTime; // %

                Real    maxTime; // %

                Real    minTime; // %

                uint    numCallsThisFrame;

                Real    totalTime; // %

                ulong   totalCalls; // %

                uint    hierarchicalLvl;

            };

            
            typedef std::list<ProfileInstance> ProfileStack;
            typedef std::list<ProfileFrame> ProfileFrameList;
            typedef std::list<ProfileHistory> ProfileHistoryList;
            typedef std::map<String, ProfileHistoryList::iterator> ProfileHistoryMap;
            typedef std::map<String, bool> DisabledProfileMap;

            typedef std::list<OverlayElement*> ProfileBarList;

            ProfileStack mProfiles;

            ProfileFrameList mProfileFrame;

            ProfileHistoryList mProfileHistory;

            ProfileHistoryMap mProfileHistoryMap;

            DisabledProfileMap mDisabledProfiles;

            ProfileBarList mProfileBars;

            bool mInitialized;

            uint maxProfiles;

            Overlay* mOverlay;

            OverlayContainer* mProfileGui;

            Real mBarHeight;

            Real mGuiHeight;

            Real mGuiWidth;

            Real mBarIndent;

            Real mGuiBorderWidth;

            Real mBarLineWidth;

            uint mUpdateDisplayFrequency;

            uint mCurrentFrame;

            Timer* mTimer;

            ulong mTotalFrameTime;

            bool mEnabled;

            bool mEnableStateChangePending;

            bool mNewEnableState;

    }; // end class

} // end namespace

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:47 2006