CEGUIRenderer.h

Go to the documentation of this file.

/***********************************************************************
    created:    Tue Apr 30 2013
    authors:    Paul D Turner <paul@cegui.org.uk>
                Lukas E Meindl
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2013 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.
 ***************************************************************************/
#pragma once
#ifndef DVD_CEGUIRenderer_Divide_h_
#define DVD_CEGUIRenderer_Divide_h_
 
#include "CEGUI/Base.h"
#include "CEGUI/Renderer.h"
#include "CEGUI/Size.h"
#include "CEGUI/Vector.h"
#include "CEGUI/Rect.h"
#include "CEGUI/TextureTarget.h"
 
#include "CEGUI/Config.h"
 
#include <glm/mat4x4.hpp>
 
#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4251)
#endif
 
namespace Divide
{
    class Texture;
    class Pipeline;
    class GFXDevice;
    class ShaderProgram;
 
    namespace GFX
    {
        class CommandBuffer;
        struct MemoryBarrierCommand;
    }
};
 
namespace CEGUI
{
 
class DVDTexture;
class DVDGeometryBuffer;
class CEGUIRenderer;
 
class CEGUIRenderer final : public Renderer
{
public:
    enum class PipelineType : Divide::U8
    {
        BLEND_NORMAL_NO_SCISSOR = 0,
        BLEND_NORMAL_SCISSOR,
        BLEND_PREMULTIPLIED_NO_SCISSOR,
        BLEND_PREMULTIPLIED_SCISSOR,
        COUNT
    };
 
private:
    using TextureTargetList = Divide::vector<TextureTarget*>;
    using GeometryBufferList = Divide::vector<DVDGeometryBuffer*>;
    using TextureMap = std::map<String, DVDTexture*, StringFastLessCompare CEGUI_MAP_ALLOC( String, DVDTexture* )>;
    using PipelineContainer = std::array<Divide::Pipeline*, Divide::to_base( PipelineType::COUNT )>;
 
public:
    static CEGUIRenderer& create( Divide::GFXDevice& context, Divide::Handle<Divide::ShaderProgram> shader, CEGUI::Sizef resolution, int abi = CEGUI_VERSION_ABI );
    static void destroy( CEGUIRenderer& renderer );
 
#pragma region Renderer Interface
    void beginRendering() override;
    void endRendering() override;
 
    void destroyGeometryBuffer(const GeometryBuffer& buffer) override;
    void destroyAllGeometryBuffers() override;
    void destroyTextureTarget(TextureTarget* target) override;
    void destroyAllTextureTargets() override;
    void destroyTexture(Texture& texture) override;
    void destroyTexture(const String& name) override;
    void destroyAllTextures() override;
    void setDisplaySize(const Sizef& sz) override;
 
    [[nodiscard]] RenderTarget& getDefaultRenderTarget() override;
    [[nodiscard]] GeometryBuffer& createGeometryBuffer() override;
    [[nodiscard]] TextureTarget* createTextureTarget() override;
    [[nodiscard]] Texture& createTexture(const String& name) override;
    [[nodiscard]] Texture& createTexture(const String& name, const String& filename, const String& resourceGroup) override;
    [[nodiscard]] Texture& createTexture(const String& name, const Sizef& size) override;
    [[nodiscard]] Texture& getTexture(const String& name) const override;
    [[nodiscard]] bool isTextureDefined(const String& name) const override;
    [[nodiscard]] const Sizef& getDisplaySize() const override;
    [[nodiscard]] const Vector2f& getDisplayDPI() const override;
    [[nodiscard]] uint getMaxTextureSize() const override;
    [[nodiscard]] const String& getIdentifierString() const override;
#pragma endregion
 
    Texture& createTexture(const String& name, const Divide::Handle<Divide::Texture> tex, const Sizef& sz);
    void setViewProjectionMatrix(const glm::mat4& viewProjectionMatrix);
    void setActiveRenderTarget(RenderTarget* renderTarget);
 
    void beginRendering( Divide::GFX::CommandBuffer& bufferInOut, Divide::GFX::MemoryBarrierCommand& memCmdInOut);
    void bindDefaultState( bool scissor, BlendMode mode, const glm::mat4& viewProjMat );
 
    [[nodiscard]] const Rectf& getActiveViewPort() const;
    [[nodiscard]] Divide::Handle<Divide::Texture> getTextureTarget() const;
    [[nodiscard]] Divide::GFXDevice& context();
    [[nodiscard]] bool flipClippingHeight() const noexcept;
    [[nodiscard]] Divide::GFX::CommandBuffer* cmdBuffer() const;
    [[nodiscard]] Divide::GFX::MemoryBarrierCommand* memCmd() const;
    [[nodiscard]] const glm::mat4& getViewProjectionMatrix() const noexcept;
 
private:
    CEGUIRenderer( Divide::GFXDevice& context, Divide::Handle<Divide::ShaderProgram> shader, CEGUI::Sizef resolution);
    virtual ~CEGUIRenderer() override;
 
    static void LogTextureCreation(const String& name);
    static void LogTextureDestruction(const String& name);
 
private:
    const bool _flipClippingHeight;
    Divide::GFXDevice& _context;
    Divide::GFX::CommandBuffer* _bufferInOut{nullptr};
    Divide::GFX::MemoryBarrierCommand* _memCmdInOut{nullptr};
    static String s_rendererID;
    Sizef _displaySize{};
    Vector2f _displayDPI{};
    RenderTarget* _defaultTarget{nullptr};
    TextureTargetList _textureTargets;
    GeometryBufferList _geometryBuffers;
    TextureMap _textures;
    glm::mat4  _viewProjectionMatrix;
    RenderTarget* _activeRenderTarget{nullptr};
    PipelineContainer _pipelines;
    PipelineType _activePipelineType{PipelineType::COUNT};
};
 
}
 
#if defined(_MSC_VER)
#   pragma warning(pop)
#endif
 
#endif //DVD_CEGUIRenderer_Divide_h_
 
#include "CEGUIRenderer.inl"