renderer.h

/***********************************************************************
        filename:       renderer.h
        created:        15/3/2004
        author:         Paul D Turner
        
        purpose:        Interface for DirectX 8.1 Renderer class
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
 *
 *   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 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.
 ***************************************************************************/
/*************************************************************************
        This file contains code that is specific to Win32 and DirectX
*************************************************************************/
#ifndef _DirectX81GUIRenderer_h_
#define _DirectX81GUIRenderer_h_

#if !defined(CEGUI_STATIC)
        #ifdef DIRECTX81_GUIRENDERER_EXPORTS
        #define DIRECTX81_GUIRENDERER_API __declspec(dllexport)
        #else
        #define DIRECTX81_GUIRENDERER_API __declspec(dllimport)
        #endif
#else
        #define DIRECTX81_GUIRENDERER_API
#endif

#include "CEGUIBase.h"
#include "CEGUIRenderer.h"
#include "CEGUITexture.h"
#include <d3d8.h>
#include <list>
#include <set>


#if defined(_MSC_VER)
#       pragma warning(push)
#       pragma warning(disable : 4251)
#endif


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

class DIRECTX81_GUIRENDERER_API DirectX81Renderer : public Renderer
{
public:
        DirectX81Renderer(LPDIRECT3DDEVICE8 device, uint max_quads = 0);


        DirectX81Renderer(LPDIRECT3DDEVICE8 device, const Size& sz);


        virtual ~DirectX81Renderer(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);

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

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

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

        // return ptr to device
        LPDIRECT3DDEVICE8       getDevice(void) const           {return d_device;}


        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 d_maxTextureSize;}


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


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


        virtual void    preD3DReset(void);


        virtual void    postD3DReset(void);


        void    setDisplaySize(const Size& sz);


private:
        /************************************************************************
                Implementation Constants
        ************************************************************************/
        static const int                        VERTEX_PER_QUAD;                                                        
        static const int                        VERTEX_PER_TRIANGLE;                                            
        static const int                        VERTEXBUFFER_CAPACITY;                                          
        static const ulong                      VERTEX_FVF;                                                                     

        /*************************************************************************
            Implementation Structs & classes
        *************************************************************************/
        struct QuadVertex {
                FLOAT x, y, z, rhw;             
                DWORD diffuse;                  
                float tu1, tv1;                 
        };

        struct QuadInfo
        {
                LPDIRECT3DTEXTURE8      texture;
                Rect                            position;
                float                           z;
                Rect                            texPosition;
                ulong                           topLeftCol;
                ulong                           topRightCol;
                ulong                           bottomLeftCol;
                ulong                           bottomRightCol;

        QuadSplitMode       splitMode;

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


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

        // renders whatever is in the vertex buffer
        void    renderVBuffer(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);

        // return size of device view port (if possible)
        Size    getViewportSize(void);

        // method to do work of constructor
        void    constructor_impl(LPDIRECT3DDEVICE8 device, const Size& display_size);


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

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

        LPDIRECT3DDEVICE8               d_device;                       
        LPDIRECT3DTEXTURE8              d_currTexture;          
        LPDIRECT3DVERTEXBUFFER8 d_buffer;                       
        int                                             d_bufferPos;            

        std::list<DirectX81Texture*>    d_texturelist;          

        uint    d_maxTextureSize;               
        bool    d_canGetVPSize;                 
};

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#       pragma warning(pop)
#endif

#endif  // end of guard _DirectX81GUIRenderer_h_