OgreOverlayManager.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.
-----------------------------------------------------------------------------
*/
#ifndef __OverlayManager_H__
#define __OverlayManager_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreStringVector.h"
#include "OgreOverlay.h"
#include "OgreScriptLoader.h"

namespace Ogre {

    class _OgreExport OverlayManager : public Singleton<OverlayManager>, public ScriptLoader
    {
    public:
        typedef std::map<String, Overlay*> OverlayMap;
        typedef std::map<String, OverlayElement*> ElementMap;
    protected:
        OverlayMap mOverlayMap;
        StringVector mScriptPatterns;

        void parseNewElement( DataStreamPtr& chunk, String& elemType, String& elemName, 
            bool isContainer, Overlay* pOverlay, bool isTemplate, String templateName = String(""), OverlayContainer* container = 0);
        void parseAttrib( const String& line, Overlay* pOverlay);
        void parseElementAttrib( const String& line, Overlay* pOverlay, OverlayElement* pElement );
        void skipToNextCloseBrace(DataStreamPtr& chunk);
        void skipToNextOpenBrace(DataStreamPtr& chunk);
        
        int mLastViewportWidth, mLastViewportHeight;
        bool mViewportDimensionsChanged;

        bool parseChildren( DataStreamPtr& chunk, const String& line,
            Overlay* pOverlay, bool isTemplate, OverlayContainer* parent = NULL);

        typedef std::map<String, OverlayElementFactory*> FactoryMap;
        FactoryMap mFactories;

        ElementMap mInstances;
        ElementMap mTemplates;

        typedef std::set<String> LoadedScripts;
        LoadedScripts mLoadedScripts;




        ElementMap& getElementMap(bool isTemplate);

        OverlayElement* createOverlayElementImpl(const String& typeName, const String& instanceName, ElementMap& elementMap);

        OverlayElement* getOverlayElementImpl(const String& name, ElementMap& elementMap);

        void destroyOverlayElementImpl(const String& instanceName, ElementMap& elementMap);

        void destroyOverlayElementImpl(OverlayElement* pInstance, ElementMap& elementMap);

        void destroyAllOverlayElementsImpl(ElementMap& elementMap);

    public:
        OverlayManager();
        virtual ~OverlayManager();

        const StringVector& getScriptPatterns(void) const;
        void parseScript(DataStreamPtr& stream, const String& groupName);
        Real getLoadingOrder(void) const;

        Overlay* create(const String& name);
        Overlay* getByName(const String& name);
        void destroy(const String& name);
        void destroy(Overlay* overlay);
        void destroyAll(void);
        typedef MapIterator<OverlayMap> OverlayMapIterator;
        OverlayMapIterator getOverlayIterator(void);

        void _queueOverlaysForRendering(Camera* cam, RenderQueue* pQueue, Viewport *vp);

        bool hasViewportChanged(void) const;

        int getViewportHeight(void) const;
        
        int getViewportWidth(void) const;
        Real getViewportAspectRatio(void) const;


        OverlayElement* createOverlayElement(const String& typeName, const String& instanceName, bool isTemplate = false);

        OverlayElement* getOverlayElement(const String& name, bool isTemplate = false);

        void destroyOverlayElement(const String& instanceName, bool isTemplate = false);

        void destroyOverlayElement(OverlayElement* pInstance, bool isTemplate = false);

        void destroyAllOverlayElements(bool isTemplate = false);

        void addOverlayElementFactory(OverlayElementFactory* elemFactory);

        OverlayElement* createOverlayElementFromTemplate(const String& templateName, const String& typeName, const String& instanceName, bool isTemplate = false);
        OverlayElement* cloneOverlayElementFromTemplate(const String& templateName, const String& instanceName);

        OverlayElement* createOverlayElementFromFactory(const String& typeName, const String& instanceName);

        typedef MapIterator<ElementMap> TemplateIterator;
        TemplateIterator getTemplateIterator ()
        {
            return TemplateIterator (mTemplates.begin (), mTemplates.end ()) ;
        }
        /* Returns whether the Element with the given name is a Template */
        bool isTemplate (String strName) const {
            return (mTemplates.find (strName) != mTemplates.end()) ;
        }


        static OverlayManager& getSingleton(void);
        static OverlayManager* getSingletonPtr(void);
    };



}


#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:45 2006