OgreCEGUIRenderer.h

Go to the documentation of this file.

/************************************************************************
    filename:   OgreCEGUIRenderer.h
    created:    11/5/2004
    author:     Paul D Turner

    purpose:    Interface for main Ogre GUI renderer class
*************************************************************************/
/*************************************************************************
    Crazy Eddie's GUI System (http://www.cegui.org.uk)
    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)

    This library 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.1 of the License, or (at your option) any later version.

    This library 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 library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*************************************************************************/
/*************************************************************************
    This file contains code that is specific to Ogre (http://www.ogre3d.org)
*************************************************************************/
#ifndef _OgreCEGUIRenderer_h_
#define _OgreCEGUIRenderer_h_

#include <CEGUIBase.h>
#include <CEGUIRenderer.h>
#include <CEGUITexture.h>

#include <OgreRenderQueueListener.h>
#include <OgreSceneManagerEnumerator.h>
#include <OgreTextureUnitState.h>

#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32) && !defined(OGRE_GUIRENDERER_STATIC_LIB)
#   ifdef OGRE_GUIRENDERER_EXPORTS
#       define OGRE_GUIRENDERER_API __declspec(dllexport)
#   else
#       if defined(__MINGW32__)
#           define OGRE_GUIRENDERER_API
#       else
#           define OGRE_GUIRENDERER_API __declspec(dllimport)
#       endif
#   endif
#elif defined ( OGRE_GCC_VISIBILITY )
#    define OGRE_GUIRENDERER_API  __attribute__ ((visibility("default")))
#else
#    define OGRE_GUIRENDERER_API
#endif


// Start of CEGUI namespace section
namespace CEGUI
{
/*************************************************************************
    Forward refs
*************************************************************************/
class OgreCEGUITexture;
class OgreCEGUIRenderer;


class _OgrePrivate CEGUIRQListener : public Ogre::RenderQueueListener
{
public:
    CEGUIRQListener(OgreCEGUIRenderer* renderer, Ogre::uint8 queue_id, bool post_queue)
    {
        d_renderer      = renderer;
        d_queue_id      = queue_id;
        d_post_queue    = post_queue;
    }

    virtual ~CEGUIRQListener() {}

    virtual void    renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue);
    virtual void    renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue);

    // methods for adjusting target queue settings
    void    setTargetRenderQueue(Ogre::uint8 queue_id)      {d_queue_id = queue_id;}
    void    setPostRenderQueue(bool post_queue)     {d_post_queue = post_queue;}

private:
    /*************************************************************************
        Implementation Data
    *************************************************************************/
    OgreCEGUIRenderer*              d_renderer;     
    Ogre::uint8 d_queue_id;     
    bool                        d_post_queue;   
};


class OGRE_GUIRENDERER_API OgreCEGUIRenderer : public Renderer
{
public:
    OgreCEGUIRenderer(Ogre::RenderWindow* window,
        Ogre::uint8 queue_id = Ogre::RENDER_QUEUE_OVERLAY,
        bool post_queue = false, uint max_quads = 0);


    OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager);


    virtual ~OgreCEGUIRenderer(void);



    // add's a quad to the list to be rendered
    virtual void    addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);

    // perform final rendering for all queued renderable quads.
    virtual void    doRender(void);

    // clear the queue
    virtual void    clearRenderList(void);


    virtual void    setQueueingEnabled(bool setting)        {d_queueing = setting;}


    // create an empty texture
    virtual Texture*    createTexture(void);

    // create a texture and load it with the specified file.
    virtual Texture*    createTexture(const String& filename, const String& resourceGroup = "General");

    // create a texture and set it to the specified size
    virtual Texture*    createTexture(float size);

    // create an OGRE resource provider.
    virtual ResourceProvider* createResourceProvider(void);

    // destroy the given texture
    virtual void        destroyTexture(Texture* texture);

    // destroy all textures still active
    virtual void        destroyAllTextures(void);


    virtual bool    isQueueingEnabled(void) const   {return d_queueing;}


    virtual float   getWidth(void) const        {return d_display_area.getWidth();}


    virtual float   getHeight(void) const       {return d_display_area.getHeight();}


    virtual Size    getSize(void) const         {return d_display_area.getSize();}


    virtual Rect    getRect(void) const         {return d_display_area;}


    virtual uint    getMaxTextureSize(void) const       {return 2048;}      // TODO: Change to proper value


    virtual uint    getHorzScreenDPI(void) const    {return 96;}


    virtual uint    getVertScreenDPI(void) const    {return 96;}


    void    setTargetSceneManager(Ogre::SceneManager* scene_manager);


    void    setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue);


    Texture*    createTexture(Ogre::TexturePtr& texture);


    void    setDisplaySize(const Size& sz);


private:
    /************************************************************************
        Implementation Constants
    ************************************************************************/
    static const size_t    VERTEX_PER_QUAD;                      
    static const size_t    VERTEX_PER_TRIANGLE;                  
    static const size_t    VERTEXBUFFER_INITIAL_CAPACITY;        
    static const size_t    UNDERUSED_FRAME_THRESHOLD;            

    /*************************************************************************
        Implementation Structs & classes
    *************************************************************************/
    struct QuadVertex {
        float x, y, z;          
        Ogre::RGBA diffuse;     
        float tu1, tv1;         
    };

    struct QuadInfo
    {
        Ogre::TexturePtr        texture;
        Rect                position;
        float               z;
        Rect                texPosition;
        uint32              topLeftCol;
        uint32              topRightCol;
        uint32              bottomLeftCol;
        uint32              bottomRightCol;

        QuadSplitMode       splitMode;

        bool operator<(const QuadInfo& other) const
        {
            // this is intentionally reversed.
            return z > other.z;
        }
    };


    /*************************************************************************
        Implementation Methods
    *************************************************************************/
    // setup states etc
    void    initRenderStates(void);

    // sort quads list according to texture
    void    sortQuads(void);

    // render a quad directly to the display
    void    renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);

    // convert colour value to whatever the Ogre render system is expecting.
    uint32    colourToOgre(const colour& col) const;

    // perform main work of the constructor.  This does everything except the final hook into the render system.
    void    constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads);


    /*************************************************************************
        Implementation Data
    *************************************************************************/
    Rect                d_display_area;

    typedef std::multiset<QuadInfo>     QuadList;
    QuadList d_quadlist;
    bool     d_queueing;        

    // Ogre specific bits.
    Ogre::Root*                 d_ogre_root;        
    Ogre::RenderSystem*         d_render_sys;       
    Ogre::uint8 d_queue_id;         
    Ogre::TexturePtr            d_currTexture;      
    Ogre::RenderOperation       d_render_op;        
    Ogre::HardwareVertexBufferSharedPtr d_buffer;   
    size_t d_underused_framecount;                  
    Ogre::RenderOperation       d_direct_render_op;     
    Ogre::HardwareVertexBufferSharedPtr d_direct_buffer;    
    Ogre::SceneManager*         d_sceneMngr;        
    Ogre::LayerBlendModeEx      d_colourBlendMode;  
    Ogre::LayerBlendModeEx      d_alphaBlendMode;   
    Ogre::TextureUnitState::UVWAddressingMode d_uvwAddressMode;

    CEGUIRQListener*            d_ourlistener;
    bool                        d_post_queue;       
    size_t                      d_bufferPos;        
    bool                        d_sorted;           
    Point                       d_texelOffset;      

    std::list<OgreCEGUITexture*> d_texturelist;     
};

} // End of  CEGUI namespace section


#endif  // end of guard _OgreCEGUIRenderer_h_