OgreOverlayElement.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 __OverlayElement_H__
#define __OverlayElement_H__

#include "OgrePrerequisites.h"
#include "OgreString.h"
#include "OgreRenderable.h"
#include "OgreStringInterface.h"
#include "OgreOverlayElementCommands.h"

#include "OgreColourValue.h"
#include "OgreRectangle.h"

namespace Ogre {


    enum GuiMetricsMode
    {
        GMM_RELATIVE,
        GMM_PIXELS,
        GMM_RELATIVE_ASPECT_ADJUSTED
    };

    enum GuiHorizontalAlignment
    {
        GHA_LEFT,
        GHA_CENTER,
        GHA_RIGHT
    };
    enum GuiVerticalAlignment
    {
        GVA_TOP,
        GVA_CENTER,
        GVA_BOTTOM
    };

    class _OgreExport OverlayElement : public StringInterface, public Renderable
    {
    public:

    protected:
        // Command object for setting / getting parameters
        static OverlayElementCommands::CmdLeft msLeftCmd;
        static OverlayElementCommands::CmdTop msTopCmd;
        static OverlayElementCommands::CmdWidth msWidthCmd;
        static OverlayElementCommands::CmdHeight msHeightCmd;
        static OverlayElementCommands::CmdMaterial msMaterialCmd;
        static OverlayElementCommands::CmdCaption msCaptionCmd;
        static OverlayElementCommands::CmdMetricsMode msMetricsModeCmd;
        static OverlayElementCommands::CmdHorizontalAlign msHorizontalAlignCmd;
        static OverlayElementCommands::CmdVerticalAlign msVerticalAlignCmd;
        static OverlayElementCommands::CmdVisible msVisibleCmd;


        String mName;
        bool mVisible;
        bool mCloneable;
        Real mLeft;
        Real mTop;
        Real mWidth;
        Real mHeight;
        String mMaterialName;
        MaterialPtr mpMaterial;
        String mCaption;
        ColourValue mColour;
        Rectangle mClippingRegion;

        GuiMetricsMode mMetricsMode;
        GuiHorizontalAlignment mHorzAlign;
        GuiVerticalAlignment mVertAlign;

        // metric-mode positions, used in GMM_PIXELS & GMM_RELATIVE_ASPECT_ADJUSTED mode.
        Real mPixelTop;
        Real mPixelLeft;
        Real mPixelWidth;
        Real mPixelHeight;
        Real mPixelScaleX;
        Real mPixelScaleY;

        // Parent pointer
        OverlayContainer* mParent;
        // Overlay attached to
        Overlay* mOverlay;

        // Derived positions from parent
        Real mDerivedLeft;
        Real mDerivedTop;
        bool mDerivedOutOfDate;

        bool mGeomPositionsOutOfDate;
        bool mGeomUVsOutOfDate;

        // Zorder for when sending to render queue
        // Derived from parent
        ushort mZOrder;

        // world transforms
        Matrix4 mXForm;

        // is element enabled
        bool mEnabled;

        // is element initialised
        bool mInitialised;

        // Used to see if this element is created from a Template
        OverlayElement* mSourceTemplate ;

        virtual void updatePositionGeometry(void) = 0;
        virtual void updateTextureGeometry(void) = 0;

        virtual void addBaseParameters(void);

    public:
        OverlayElement(const String& name);
        virtual ~OverlayElement();

        virtual void initialise(void) = 0;

        const String& getName(void) const;


        virtual void show(void);

        virtual void hide(void);

        bool isVisible(void) const;

        bool isEnabled() const;
        virtual void setEnabled(bool b);


        void setDimensions(Real width, Real height);

        void setPosition(Real left, Real top);

        void setWidth(Real width);
        Real getWidth(void) const;

        void setHeight(Real height);
        Real getHeight(void) const;

        void setLeft(Real left);
        Real getLeft(void) const;

        void setTop(Real Top);
        Real getTop(void) const;

        Real _getLeft(void) const { return mLeft; }
        Real _getTop(void) const { return mTop; }
        Real _getWidth(void) const { return mWidth; }
        Real _getHeight(void) const { return mHeight; }
        void _setLeft(Real left);
        void _setTop(Real top);
        void _setWidth(Real width);
        void _setHeight(Real height);
        void _setPosition(Real left, Real top);
        void _setDimensions(Real width, Real height);

        virtual const String& getMaterialName(void) const;

        virtual void setMaterialName(const String& matName);


        // --- Renderable Overrides ---
        const MaterialPtr& getMaterial(void) const;

        // NB getRenderOperation not implemented, still abstract here

        void getWorldTransforms(Matrix4* xform) const;
        const Quaternion& getWorldOrientation(void) const;
        const Vector3& getWorldPosition(void) const;

        bool useIdentityProjection(void) const;

        bool useIdentityView(void) const;

        virtual void _positionsOutOfDate(void);

        virtual void _update(void);

        virtual void _updateFromParent(void);

        virtual void _notifyParent(OverlayContainer* parent, Overlay* overlay);

        virtual Real _getDerivedLeft(void);

        virtual Real _getDerivedTop(void);

        virtual void _getClippingRegion(Rectangle &clippingRegion);

        virtual void _notifyZOrder(ushort newZOrder);

        virtual void _notifyWorldTransforms(const Matrix4& xform);

        virtual void _notifyViewport();

        virtual void _updateRenderQueue(RenderQueue* queue);

        virtual const String& getTypeName(void) const = 0;

        virtual void setCaption(const String& text);

        virtual const String& getCaption(void) const;

        virtual void setColour(const ColourValue& col);

        virtual const ColourValue& getColour(void) const;

        virtual void setMetricsMode(GuiMetricsMode gmm);
        virtual GuiMetricsMode getMetricsMode(void) const;
        virtual void setHorizontalAlignment(GuiHorizontalAlignment gha);
        virtual GuiHorizontalAlignment getHorizontalAlignment(void) const;
        virtual void setVerticalAlignment(GuiVerticalAlignment gva);
        virtual GuiVerticalAlignment getVerticalAlignment(void) const;




        virtual bool contains(Real x, Real y) const;

        virtual OverlayElement* findElementAt(Real x, Real y);      // relative to parent

        inline virtual bool isContainer() const
        { return false; }

        inline virtual bool isKeyEnabled() const
        { return false; }

        inline virtual bool isCloneable() const
        { return mCloneable; }

        inline virtual void setCloneable(bool c)
        { mCloneable = c; }

        OverlayContainer* getParent() ;
        void _setParent(OverlayContainer* parent) { mParent = parent; }

        inline ushort getZOrder() const
        { return mZOrder; }

        Real getSquaredViewDepth(const Camera* cam) const 
        { 
            return 10000 - getZOrder(); 
        }

        const LightList& getLights(void) const
        {
            // Overlayelements should not be lit by the scene, this will not get called
            static LightList ll;
            return ll;
        }

        void copyFromTemplate(OverlayElement* templateOverlay);
        virtual OverlayElement* clone(const String& instanceName);

        // Returns the SourceTemplate for this element
        const OverlayElement* getSourceTemplate () const {
          return mSourceTemplate ;
        }
    };



}


#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