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-2014 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/

#ifndef __OverlayElement_H__
#define __OverlayElement_H__

#include "OgreOverlayPrerequisites.h"
#include "OgreString.h"
#include "OgreRenderable.h"
#include "OgreUTFString.h"
#include "OgreStringInterface.h"
#include "OgreOverlayElementCommands.h"

#include "OgreColourValue.h"

namespace Ogre {
#if OGRE_UNICODE_SUPPORT
    typedef UTFString DisplayString;
#   define OGRE_DEREF_DISPLAYSTRING_ITERATOR(it) it.getCharacter()
#else
    typedef String DisplayString;
#   define OGRE_DEREF_DISPLAYSTRING_ITERATOR(it) *it
#endif

    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 _OgreOverlayExport OverlayElement : public StringInterface, public Renderable, public OverlayAlloc
    {
    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 mMaterial;
        DisplayString mCaption;
        ColourValue mColour;
        RealRect 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;

        OverlayContainer* mParent;
        Overlay* mOverlay;

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

        bool mGeomPositionsOutOfDate;
        bool mGeomUVsOutOfDate;

        ushort mZOrder;

        Matrix4 mXForm;

        bool mEnabled;

        bool mInitialised;

        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;

        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 Real _getRelativeWidth(void);
        virtual Real _getRelativeHeight(void);


        virtual void _getClippingRegion(RealRect &clippingRegion);

        virtual ushort _notifyZOrder(ushort newZOrder);

        virtual void _notifyWorldTransforms(const Matrix4& xform);

        virtual void _notifyViewport();

        virtual void _updateRenderQueue(RenderQueue* queue);

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

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

        virtual void setCaption(const DisplayString& text);
        virtual const DisplayString& 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 
        { 
            (void)cam;
            return 10000.0f - (Real)getZOrder(); 
        }

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

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

        const OverlayElement* getSourceTemplate () const {
          return mSourceTemplate ;
        }
    };


}


#endif