renderabletextcomponent.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "rendercomponent.h"
#include "materialinstance.h"
#include "renderableglyph.h"
#include "color.h"
 
// External Includes
#include <font.h>
#include <planemesh.h>
#include <renderablemesh.h>
#include <transformcomponent.h>
 
namespace nap
{
    class RenderableTextComponentInstance;
 
    class NAPAPI RenderableTextComponent : public RenderableComponent
    {
        RTTI_ENABLE(RenderableComponent)
        DECLARE_COMPONENT(RenderableTextComponent, RenderableTextComponentInstance)
    public:
        ResourcePtr<Font> mFont;                                
        std::string mText;                                      
        RGBColorFloat mColor = { 1.0f, 1.0f, 1.0f };            
    };
 
 
    class NAPAPI RenderableTextComponentInstance : public RenderableComponentInstance
    {
        RTTI_ENABLE(RenderableComponentInstance)
    public:
 
        RenderableTextComponentInstance(EntityInstance& entity, Component& resource);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        const FontInstance& getFont() const;
 
        bool setText(const std::string& text, utility::ErrorState& error);
 
        void setColor(const glm::vec3& color);
 
        bool setText(int lineIndex, const std::string& text, utility::ErrorState& error);
 
        bool addLine(const std::string& text, utility::ErrorState& error);
 
        void setLineIndex(int index);
 
        const std::string& getText() const;
 
        const std::string& getText(int index) const;
 
        void resize(int lines);
 
        int getCount() const;
 
        void clear();
 
        const math::Rect& getBoundingBox() const;
 
        const math::Rect& getBoundingBox(int index);
 
        virtual RenderableGlyph* getRenderableGlyph(uint index, float scale, utility::ErrorState& error) const = 0;
 
        const MaterialInstance& getMaterialInstance() const             { return mMaterialInstance; }
 
        MaterialInstance& getMaterialInstance()                         { return mMaterialInstance; }
 
        void setDPIScale(float scale);
 
        float getDPIScale() const                                       { return mScale; }
 
    protected:
        void draw(IRenderTarget& renderTarget, VkCommandBuffer commandBuffer, const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix, const glm::mat4& modelMatrix);
 
        bool hasTransform() const                                       { return mTransform != nullptr; }
 
        const nap::TransformComponentInstance* getTransform() const     { return mTransform; }          
 
        virtual bool setup(float scale, utility::ErrorState& errorState);
 
        const std::vector<std::string>& getLineCache() const            { return mLinesCache; }
 
        FontInstance* mFont = nullptr;                                  
        RenderService* mRenderService = nullptr;                        
 
    private:
        int mIndex = 0;                                                 
        MaterialInstance mMaterialInstance;                             
        PlaneMesh mPlane;                                               
        Sampler2DInstance* mGlyphUniform = nullptr;                     
        UniformVec3Instance* mColorUniform = nullptr;                   
        UniformMat4Instance* mModelUniform = nullptr;                   
        UniformMat4Instance* mViewUniform = nullptr;                    
        UniformMat4Instance* mProjectionUniform = nullptr;              
        TransformComponentInstance* mTransform = nullptr;               
        RenderableMesh mRenderableMesh;                                 
        VertexAttribute<glm::vec3>* mPositionAttr = nullptr;            
        std::vector<math::Rect> mTextBounds;                            
        std::vector<std::vector<RenderableGlyph*>> mGlyphCache;         
        std::vector<std::string> mLinesCache;                           
        MaterialInstanceResource mMaterialInstanceResource;             
        float mScale = 1.0f;                                            
    };
}