source: OGRE/trunk/ogrenew/OgreMain/src/OgreOverlayManager.cpp @ 657

Revision 657, 25.6 KB checked in by mattausch, 19 years ago (diff)

added ogre dependencies and patched ogre sources
Line 
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4    (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2005 The OGRE Team
8Also see acknowledgements in Readme.html
9
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://www.gnu.org/copyleft/lesser.txt.
23-----------------------------------------------------------------------------
24*/
25#include "OgreStableHeaders.h"
26
27#include "OgreOverlayManager.h"
28#include "OgreStringVector.h"
29#include "OgreOverlayContainer.h"
30#include "OgreStringConverter.h"
31#include "OgreLogManager.h"
32#include "OgreSceneManagerEnumerator.h"
33#include "OgreSceneManager.h"
34#include "OgreSceneNode.h"
35#include "OgreEntity.h"
36#include "OgreException.h"
37#include "OgreViewport.h"
38#include "OgreOverlayElementFactory.h"
39
40namespace Ogre {
41
42    //---------------------------------------------------------------------
43    template<> OverlayManager *Singleton<OverlayManager>::ms_Singleton = 0;
44    OverlayManager* OverlayManager::getSingletonPtr(void)
45    {
46        return ms_Singleton;
47    }
48    OverlayManager& OverlayManager::getSingleton(void)
49    { 
50        assert( ms_Singleton );  return ( *ms_Singleton ); 
51    }
52    //---------------------------------------------------------------------
53    OverlayManager::OverlayManager()
54      : mLastViewportWidth(0),
55        mLastViewportHeight(0),
56        mViewportDimensionsChanged(false)
57    {
58
59        // Scripting is supported by this manager
60        mScriptPatterns.push_back("*.overlay");
61                ResourceGroupManager::getSingleton()._registerScriptLoader(this);
62
63    }
64    //---------------------------------------------------------------------
65    OverlayManager::~OverlayManager()
66    {
67                destroyAllOverlayElements(false);
68                destroyAllOverlayElements(true);
69        destroyAll();
70
71        // Unregister with resource group manager
72                ResourceGroupManager::getSingleton()._unregisterScriptLoader(this);
73    }
74    //---------------------------------------------------------------------
75    const StringVector& OverlayManager::getScriptPatterns(void) const
76    {
77        return mScriptPatterns;
78    }
79    //---------------------------------------------------------------------
80    Real OverlayManager::getLoadingOrder(void) const
81    {
82        // Load late
83        return 1100.0f;
84    }
85    //---------------------------------------------------------------------
86    Overlay* OverlayManager::create(const String& name)
87    {
88        Overlay* ret = 0;
89        OverlayMap::iterator i = mOverlayMap.find(name);
90
91        if (i == mOverlayMap.end())
92        {
93            ret = new Overlay(name);
94            assert(ret && "Overlay creation failed");
95            mOverlayMap[name] = ret;
96        }
97        else
98        {
99            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
100                "Overlay with name '" + name + "' already exists!",
101                "OverlayManager::create");
102        }
103
104        return ret;
105
106    }
107    //---------------------------------------------------------------------
108    Overlay* OverlayManager::getByName(const String& name)
109    {
110        OverlayMap::iterator i = mOverlayMap.find(name);
111        if (i == mOverlayMap.end())
112        {
113            return 0;
114        }
115        else
116        {
117            return i->second;
118        }
119
120    }
121    //---------------------------------------------------------------------
122    void OverlayManager::destroy(const String& name)
123    {
124        OverlayMap::iterator i = mOverlayMap.find(name);
125        if (i == mOverlayMap.end())
126        {
127            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
128                "Overlay with name '" + name + "' not found.",
129                "OverlayManager::destroy");
130        }
131        else
132        {
133            delete i->second;
134            mOverlayMap.erase(i);
135        }
136    }
137    //---------------------------------------------------------------------
138    void OverlayManager::destroy(Overlay* overlay)
139    {
140        for (OverlayMap::iterator i = mOverlayMap.begin();
141            i != mOverlayMap.end(); ++i)
142        {
143            if (i->second == overlay)
144            {
145                delete i->second;
146                mOverlayMap.erase(i);
147                return;
148            }
149        }
150
151        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
152            "Overlay not found.",
153            "OverlayManager::destroy");
154    }
155    //---------------------------------------------------------------------
156    void OverlayManager::destroyAll(void)
157    {
158        for (OverlayMap::iterator i = mOverlayMap.begin();
159            i != mOverlayMap.end(); ++i)
160        {
161            delete i->second;
162        }
163        mOverlayMap.clear();
164                mLoadedScripts.clear();
165    }
166    //---------------------------------------------------------------------
167    OverlayManager::OverlayMapIterator OverlayManager::getOverlayIterator(void)
168    {
169        return OverlayMapIterator(mOverlayMap.begin(), mOverlayMap.end());
170    }
171    //---------------------------------------------------------------------
172    void OverlayManager::parseScript(DataStreamPtr& stream, const String& groupName)
173    {
174                // check if we've seen this script before (can happen if included
175                // multiple times)
176                if (!stream->getName().empty() &&
177                        mLoadedScripts.find(stream->getName()) != mLoadedScripts.end())
178                {
179                        LogManager::getSingleton().logMessage(
180                                "Skipping loading overlay include: '"
181                                + stream->getName() + " as it is already loaded.");
182                        return;
183                }
184            String line;
185            Overlay* pOverlay = 0;
186                bool skipLine;
187
188            while(!stream->eof())
189            {
190                        bool isTemplate = false;
191                        skipLine = false;
192                    line = stream->getLine();
193                    // Ignore comments & blanks
194                    if (!(line.length() == 0 || line.substr(0,2) == "//"))
195                    {
196                                if (line.substr(0,8) == "#include")
197                                {
198                    std::vector<String> params = StringUtil::split(line, "\t\n ()<>");
199                    DataStreamPtr includeStream =
200                        ResourceGroupManager::getSingleton().openResource(
201                            params[1], groupName);
202                                        parseScript(includeStream, groupName);
203                                        continue;
204                                }
205                            if (!pOverlay)
206                            {
207                                    // No current overlay
208
209                                        // check to see if there is a template
210                                        if (line.substr(0,8) == "template")
211                                        {
212                                                isTemplate = true;
213
214                                        }
215                                        else
216                                        {
217                       
218                                                // So first valid data should be overlay name
219                                                pOverlay = create(line);
220                                                pOverlay->_notifyOrigin(stream->getName());
221                                                // Skip to and over next {
222                                                skipToNextOpenBrace(stream);
223                                                skipLine = true;
224                                        }
225                            }
226                            if ((pOverlay && !skipLine) || isTemplate)
227                            {
228                                    // Already in overlay
229                    std::vector<String> params = StringUtil::split(line, "\t\n ()");
230
231
232                                        uint skipParam = 0;
233                                    if (line == "}")
234                                    {
235                                            // Finished overlay
236                                            pOverlay = 0;
237                                                isTemplate = false;
238                                    }
239                                    else if (parseChildren(stream,line, pOverlay, isTemplate, NULL))
240                                               
241                                    {
242
243                                    }
244                                    else if (params[0+skipParam] == "entity")
245                                    {
246                                            // new 3D element
247                        if (params.size() != (3+skipParam))
248                        {
249                                    LogManager::getSingleton().logMessage(
250                                            "Bad entity line: '"
251                                            + line + "' in " + pOverlay->getName() +
252                                            ", expecting 'entity meshName(entityName)'");
253                                skipToNextCloseBrace(stream);
254                        }
255                        else
256                        {
257                            skipToNextOpenBrace(stream);
258                                                parseNewMesh(stream, params[1+skipParam], params[2+skipParam], pOverlay);
259                        }
260
261                                    }
262                                    else
263                                    {
264                                            // Attribute
265                                                if (!isTemplate)
266                                                {
267                                                        parseAttrib(line, pOverlay);
268                                                }
269                                    }
270
271                            }
272
273                    }
274
275
276            }
277
278                // record as parsed
279                mLoadedScripts.insert(stream->getName());
280
281    }
282    //---------------------------------------------------------------------
283    void OverlayManager::_queueOverlaysForRendering(Camera* cam,
284        RenderQueue* pQueue, Viewport* vp)
285    {
286        // Flag for update pixel-based GUIElements if viewport has changed dimensions
287        if (mLastViewportWidth != vp->getActualWidth() ||
288            mLastViewportHeight != vp->getActualHeight())
289        {
290            mViewportDimensionsChanged = true;
291            mLastViewportWidth = vp->getActualWidth();
292            mLastViewportHeight = vp->getActualHeight();
293
294        }
295        else
296        {
297            mViewportDimensionsChanged = false;
298        }
299
300        OverlayMap::iterator i, iend;
301        iend = mOverlayMap.end();
302        for (i = mOverlayMap.begin(); i != iend; ++i)
303        {
304            Overlay* o = i->second;
305            o->_findVisibleObjects(cam, pQueue);
306        }
307    }
308    //---------------------------------------------------------------------
309    void OverlayManager::parseNewElement( DataStreamPtr& stream, String& elemType, String& elemName,
310            bool isContainer, Overlay* pOverlay, bool isTemplate, String templateName, OverlayContainer* container)
311    {
312        String line;
313
314                OverlayElement* newElement = NULL;
315                newElement =
316                                OverlayManager::getSingleton().createOverlayElementFromTemplate(templateName, elemType, elemName, isTemplate);
317
318                        // do not add a template to an overlay
319
320                // add new element to parent
321                if (container)
322                {
323                        // Attach to container
324                        container->addChild(newElement);
325                }
326                // do not add a template to the overlay. For templates overlay = 0
327                else if (pOverlay)     
328                {
329                        pOverlay->add2D((OverlayContainer*)newElement);
330                }
331
332        while(!stream->eof())
333        {
334            line = stream->getLine();
335            // Ignore comments & blanks
336            if (!(line.length() == 0 || line.substr(0,2) == "//"))
337            {
338                if (line == "}")
339                {
340                    // Finished element
341                    break;
342                }
343                else
344                {
345                    if (isContainer && parseChildren(stream,line, pOverlay, isTemplate, static_cast<OverlayContainer*>(newElement)))
346                    {
347                                            // nested children... don't reparse it
348                    }
349                    else
350                    {
351                        // Attribute
352                        parseElementAttrib(line, pOverlay, newElement);
353                    }
354                }
355            }
356        }
357    }
358
359    //---------------------------------------------------------------------
360    bool OverlayManager::parseChildren( DataStreamPtr& stream, const String& line,
361            Overlay* pOverlay, bool isTemplate, OverlayContainer* parent)
362        {
363                bool ret = false;
364                std::vector<String> params;
365                uint skipParam =0;
366                params = StringUtil::split(line, "\t\n ()");
367
368                if (isTemplate)
369                {
370                        if (params[0] == "template")
371                        {
372                                skipParam++;            // the first param = 'template' on a new child element
373                        }
374                }
375                                               
376                // top level component cannot be an element, it must be a container unless it is a template
377                if (params[0+skipParam] == "container" || (params[0+skipParam] == "element" && (isTemplate || parent != NULL)) )
378                {
379                        String templateName = "";
380                        ret = true;
381                        // nested container/element
382                        if (params.size() > 3+skipParam)
383                        {
384                                if (params.size() != 5+skipParam)
385                                {
386                                        LogManager::getSingleton().logMessage(
387                                                "Bad element/container line: '"
388                                                + line + "' in " + parent->getTypeName()+ " " + parent->getName() +
389                                                ", expecting ':' templateName");
390                                        skipToNextCloseBrace(stream);
391                                        // barf
392                                        return ret;
393                                }
394                                if (params[3+skipParam] != ":")
395                                {
396                                        LogManager::getSingleton().logMessage(
397                                                "Bad element/container line: '"
398                                                + line + "' in " + parent->getTypeName()+ " " + parent->getName() +
399                                                ", expecting ':' for element inheritance");
400                                        skipToNextCloseBrace(stream);
401                                        // barf
402                                        return ret;
403                                }
404
405                                templateName = params[4+skipParam];
406                        }
407
408                        else if (params.size() != 3+skipParam)
409                        {
410                                LogManager::getSingleton().logMessage(
411                                        "Bad element/container line: '"
412                                                + line + "' in " + parent->getTypeName()+ " " + parent->getName() +
413                                        ", expecting 'element type(name)'");
414                                skipToNextCloseBrace(stream);
415                                // barf
416                                return ret;
417                        }
418       
419                        skipToNextOpenBrace(stream);
420                        parseNewElement(stream, params[1+skipParam], params[2+skipParam], true, pOverlay, isTemplate, templateName, (OverlayContainer*)parent);
421
422                }
423
424
425                return ret;
426        }
427
428    //---------------------------------------------------------------------
429    void OverlayManager::parseAttrib( const String& line, Overlay* pOverlay)
430    {
431        std::vector<String> vecparams;
432
433        // Split params on first space
434        vecparams = StringUtil::split(line, "\t ", 1);
435
436        // Look up first param (command setting)
437                StringUtil::toLowerCase(vecparams[0]);
438        if (vecparams[0] == "zorder")
439        {
440            pOverlay->setZOrder(StringConverter::parseUnsignedInt(vecparams[1]));
441        }
442        else
443        {
444            LogManager::getSingleton().logMessage("Bad overlay attribute line: '"
445                + line + "' for overlay " + pOverlay->getName());
446        }
447    }
448    //---------------------------------------------------------------------
449    void OverlayManager::parseElementAttrib( const String& line, Overlay* pOverlay, OverlayElement* pElement )
450    {
451        std::vector<String> vecparams;
452
453        // Split params on first space
454        vecparams = StringUtil::split(line, "\t ", 1);
455
456        // Look up first param (command setting)
457                StringUtil::toLowerCase(vecparams[0]);
458        if (!pElement->setParameter(vecparams[0], vecparams[1]))
459        {
460            // BAD command. BAD!
461            LogManager::getSingleton().logMessage("Bad element attribute line: '"
462                + line + "' for element " + pElement->getName() + " in overlay " +
463                (!pOverlay ? "" : pOverlay->getName().c_str() ));
464        }
465    }
466    //-----------------------------------------------------------------------
467    void OverlayManager::skipToNextCloseBrace(DataStreamPtr& stream)
468    {
469        String line = "";
470        while (!stream->eof() && line != "}")
471        {
472            line = stream->getLine();
473        }
474
475    }
476    //-----------------------------------------------------------------------
477    void OverlayManager::skipToNextOpenBrace(DataStreamPtr& stream)
478    {
479        String line = "";
480        while (!stream->eof() && line != "{")
481        {
482            line = stream->getLine();
483        }
484
485    }
486    //-----------------------------------------------------------------------
487    void OverlayManager::parseNewMesh(DataStreamPtr& stream, String& meshName, String& entityName,
488        Overlay* pOverlay)
489    {
490        String line;
491        StringVector params;
492
493        // NB at this stage any scene manager will do, it's just for allocation not rendering
494        SceneManager* sm = SceneManagerEnumerator::getSingleton().getSceneManager(ST_GENERIC);
495
496        // Create entity
497        Entity* ent = sm->createEntity(entityName, meshName);
498        // Add a new entity via a node
499        SceneNode* node = sm->createSceneNode(entityName + "_autoNode");
500
501        node->attachObject(ent);
502
503
504        // parse extra info
505        while(!stream->eof())
506        {
507            line = stream->getLine();
508            // Ignore comments & blanks
509            if (!(line.length() == 0 || line.substr(0,2) == "//"))
510            {
511                if (line == "}")
512                {
513                    // Finished
514                    break;
515                }
516                else
517                {
518                    if (line.substr(0, 8) == "position")
519                    {
520                        params = StringUtil::split(line, " \t");
521                        if (params.size() != 4)
522                        {
523                            LogManager::getSingleton().logMessage("Bad position attribute line: '"
524                                + line + "' for entity " + entityName + " in overlay " +
525                                pOverlay->getName());
526                            break;
527                        }
528                        node->translate(StringConverter::parseReal(params[1]),
529                                        StringConverter::parseReal(params[2]),
530                                        StringConverter::parseReal(params[3]));
531                    }
532                    else if (line.substr(0, 8) == "rotation")
533                    {
534                        params = StringUtil::split(line, " \t");
535                        if (params.size() != 5)
536                        {
537                            LogManager::getSingleton().logMessage("Bad rotation attribute line: '"
538                                + line + "' for entity " + entityName + " in overlay " +
539                                pOverlay->getName());
540                            break;
541                        }
542                        // in file it is angle axis_x axis_y axis_z
543                        Vector3 axis(StringConverter::parseReal(params[2]),
544                                    StringConverter::parseReal(params[3]),
545                                    StringConverter::parseReal(params[4]));
546                        node->rotate(axis, StringConverter::parseAngle(params[1]));
547                    }
548                }
549            }
550        }
551
552
553
554        // Attach node to overlay
555        pOverlay->add3D(node);
556       
557    }
558    //---------------------------------------------------------------------
559    bool OverlayManager::hasViewportChanged(void) const
560    {
561        return mViewportDimensionsChanged;
562    }
563    //---------------------------------------------------------------------
564    int OverlayManager::getViewportHeight(void) const
565    {
566        return mLastViewportHeight;
567    }
568    //---------------------------------------------------------------------
569    int OverlayManager::getViewportWidth(void) const
570    {
571        return mLastViewportWidth;
572    }
573    //---------------------------------------------------------------------
574    Real OverlayManager::getViewportAspectRatio(void) const
575    {
576        return (Real)mLastViewportHeight / (Real)mLastViewportWidth;
577    }
578    //---------------------------------------------------------------------
579        //---------------------------------------------------------------------
580        OverlayManager::ElementMap& OverlayManager::getElementMap(bool isTemplate)
581        {
582                return (isTemplate)?mTemplates:mInstances;
583        }
584
585        //---------------------------------------------------------------------
586        OverlayElement* OverlayManager::createOverlayElementFromTemplate(const String& templateName, const String& typeName, const String& instanceName, bool isTemplate)
587        {
588
589                OverlayElement* newObj  = NULL;
590
591                if (templateName == "")
592                {
593                        newObj = createOverlayElement(typeName, instanceName, isTemplate);
594                }
595                else
596                {
597                        // no template
598                        OverlayElement* templateGui = getOverlayElement(templateName, true);
599
600                        String typeNameToCreate;
601                        if (typeName == "")
602                        {
603                                typeNameToCreate = templateGui->getTypeName();
604                        }
605                        else
606                        {
607                                typeNameToCreate = typeName;
608                        }
609
610                        newObj = createOverlayElement(typeNameToCreate, instanceName, isTemplate);
611
612                        ((OverlayContainer*)newObj)->copyFromTemplate(templateGui);
613                }
614
615                return newObj;
616        }
617
618
619        //---------------------------------------------------------------------
620        OverlayElement* OverlayManager::cloneOverlayElementFromTemplate(const String& templateName, const String& instanceName)
621        {
622                OverlayElement* templateGui = getOverlayElement(templateName, true);
623                return templateGui->clone(instanceName);
624        }
625
626        //---------------------------------------------------------------------
627        OverlayElement* OverlayManager::createOverlayElement(const String& typeName, const String& instanceName, bool isTemplate)
628        {
629                return createOverlayElementImpl(typeName, instanceName, getElementMap(isTemplate));
630        }
631
632        //---------------------------------------------------------------------
633        OverlayElement* OverlayManager::createOverlayElementImpl(const String& typeName, const String& instanceName, ElementMap& elementMap)
634        {
635                // Check not duplicated
636                ElementMap::iterator ii = elementMap.find(instanceName);
637                if (ii != elementMap.end())
638                {
639                        OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "OverlayElement with name " + instanceName +
640                                " already exists.", "OverlayManager::createOverlayElement" );
641                }
642                OverlayElement* newElem = createOverlayElementFromFactory(typeName, instanceName);
643
644                // Register
645                elementMap.insert(ElementMap::value_type(instanceName, newElem));
646
647                return newElem;
648
649
650        }
651
652        //---------------------------------------------------------------------
653        OverlayElement* OverlayManager::createOverlayElementFromFactory(const String& typeName, const String& instanceName)
654        {
655                // Look up factory
656                FactoryMap::iterator fi = mFactories.find(typeName);
657                if (fi == mFactories.end())
658                {
659                        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate factory for element type " + typeName,
660                                "OverlayManager::createOverlayElement");
661                }
662
663                // create
664                return fi->second->createOverlayElement(instanceName);
665        }
666
667        //---------------------------------------------------------------------
668        OverlayElement* OverlayManager::getOverlayElement(const String& name, bool isTemplate)
669        {
670                return getOverlayElementImpl(name, getElementMap(isTemplate));
671        }
672        //---------------------------------------------------------------------
673        OverlayElement* OverlayManager::getOverlayElementImpl(const String& name, ElementMap& elementMap)
674        {
675                // Locate instance
676                ElementMap::iterator ii = elementMap.find(name);
677                if (ii == elementMap.end())
678                {
679                        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "OverlayElement with name " + name +
680                                " not found.", "OverlayManager::getOverlayElementImpl" );
681                }
682
683                return ii->second;
684        }
685        //---------------------------------------------------------------------
686        void OverlayManager::destroyOverlayElement(const String& instanceName, bool isTemplate)
687        {
688                destroyOverlayElementImpl(instanceName, getElementMap(isTemplate));
689        }
690
691        //---------------------------------------------------------------------
692        void OverlayManager::destroyOverlayElement(OverlayElement* pInstance, bool isTemplate)
693        {
694                destroyOverlayElementImpl(pInstance->getName(), getElementMap(isTemplate));
695        }
696
697        //---------------------------------------------------------------------
698        void OverlayManager::destroyOverlayElementImpl(const String& instanceName, ElementMap& elementMap)
699        {
700                // Locate instance
701                ElementMap::iterator ii = elementMap.find(instanceName);
702                if (ii == elementMap.end())
703                {
704                        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "OverlayElement with name " + instanceName +
705                                " not found.", "OverlayManager::destroyOverlayElement" );
706                }
707                // Look up factory
708                const String& typeName = ii->second->getTypeName();
709                FactoryMap::iterator fi = mFactories.find(typeName);
710                if (fi == mFactories.end())
711                {
712                        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate factory for element type " + typeName,
713                                "OverlayManager::destroyOverlayElement");
714                }
715
716                fi->second->destroyOverlayElement(ii->second);
717                elementMap.erase(ii);
718        }
719        //---------------------------------------------------------------------
720        void OverlayManager::destroyAllOverlayElements(bool isTemplate)
721        {
722                destroyAllOverlayElementsImpl(getElementMap(isTemplate));
723        }
724        //---------------------------------------------------------------------
725        void OverlayManager::destroyAllOverlayElementsImpl(ElementMap& elementMap)
726        {
727                ElementMap::iterator i;
728
729                while ((i = elementMap.begin()) != elementMap.end())
730                {
731                        OverlayElement* element = i->second;
732
733                        // Get factory to delete
734                        FactoryMap::iterator fi = mFactories.find(element->getTypeName());
735                        if (fi == mFactories.end())
736                        {
737                                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate factory for element "
738                                        + element->getName(),
739                                        "OverlayManager::destroyAllOverlayElements");
740                        }
741
742                        // remove from parent, if any
743                        OverlayContainer* parent;
744                        if ((parent = element->getParent()) != 0)
745                        {
746                                parent->_removeChild(element->getName());
747                        }
748
749                        // children of containers will be auto-removed when container is destroyed.
750                        // destroy the element and remove it from the list
751                        fi->second->destroyOverlayElement(element);
752                        elementMap.erase(i);
753                }
754        }
755        //---------------------------------------------------------------------
756        void OverlayManager::addOverlayElementFactory(OverlayElementFactory* elemFactory)
757        {
758                // Add / replace
759                mFactories[elemFactory->getTypeName()] = elemFactory;
760
761                LogManager::getSingleton().logMessage("OverlayElementFactory for type " + elemFactory->getTypeName()
762                        + " registered.");
763        }
764}
765
Note: See TracBrowser for help on using the repository browser.