TextWriter.h

Go to the documentation of this file.

//Luke Lenhart, 2010
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "../base/Setup.h"

#ifdef MPMA_COMPILE_GFX

#include "../base/Types.h"
#include "../base/Vary.h"
#include "../gfxsetup/GL.h"
#include "../gfxsetup/Extensions.h"
#include "Texture.h"
#include "Vertex.h"
#include <string>

#ifdef GFX_USES_IMAGEMAGICK

namespace
{
    class FontCacheEntry;
}

namespace GFX
{
    enum FontType
    {
        VARIABLE_SERIF   =0x0000, 
        VARIABLE_SANSERIF=0x0001, 
        FIXED_SERIF      =0x0100, 
        //FIXED_SANSERIF   =0x0101
    };

    struct TextColor
    {
        uint8 Red; 
        uint8 Green; 
        uint8 Blue; 
        uint8 Opacity; 

        TextColor(): Red(255), Green(255), Blue(255), Opacity(255) {}
        TextColor(uint8 red, uint8 green, uint8 blue, uint8 opacity=255): Red(red), Green(green), Blue(blue), Opacity(opacity) {}
    };

    class EncodedText
    {
    public:
        inline EncodedText() {}
        inline EncodedText(const std::string &plainText)
        {
            AppendPlainText(plainText);
        }

        inline void Clear()
        {
            data.clear();
        }

        void AppendColorChange(uint8 red, uint8 green, uint8 blue, uint8 opacity=255);
        inline void AppendColorChange(const TextColor &color)
        {
            AppendColorChange(color.Red, color.Green, color.Blue, color.Opacity);
        }
        void AppendPlainText(const std::string &text);

        EncodedText& operator<<(const char *sstring);
        EncodedText& operator<<(const std::string &sstring);
        EncodedText& operator<<(const MPMA::Vary &vstring);
        EncodedText& operator<<(const TextColor &color);
        EncodedText& operator<<(const EncodedText &et);
    private:
        std::vector<uint8> data;

        friend class TextWriter;
    };

    class TextWriter
    {
    public:
        static void ClearFontCache();

        // -- Step 1: Convert the text to an internal image.

        EncodedText Text;

        nuint FontSize;

        FontType TextFont;

        nuint TextWidth;

        bool CreateTextImage();

        inline nuint GetTextHeight() const { return textHeight; }

        // -- Step 2: Convert the internal image to a texture that can be used for rendering.

        nuint ViewWindowHeight;

        nuint ViewWindowScroll;

        inline nuint GetMaxViewWindowScroll() const
        {
            nsint actualViewHeight=(nsint)GetActualViewHeight();
            nsint extraHeightPixels=textHeight-actualViewHeight;
            if (extraHeightPixels<0)
                extraHeightPixels=0;
            return (nuint)extraHeightPixels;
        }

        bool DebugDrawBorder;

        bool CreateTexture();

        inline nuint GetTextureWidth();
        inline nuint GetTextureHeight();

        // -- Step 3: Render the texture using these properties.

        inline const Texture2D& GetTexture() const { return texture; }

        inline float GetTexCoordUMin() const { return renderUMin; }
        inline float GetTexCoordUMax() const { return renderUMax; }
        inline float GetTexCoordVMin() const { return renderVMin; }
        inline float GetTexCoordVMax() const { return renderVMax; }

        inline nuint GetRenderWidth() const { return renderWidth; }
        inline nuint GetRenderHeight() const { return renderHeight; }

        void RenderTexture(float leftX, float topY);

        // --

        //
        TextWriter(); 
        TextWriter(const TextWriter &other); 
        TextWriter(TextWriter &&other); 

    private:
        void Init();
        void CopyValues(const TextWriter &other, bool copyMovableValues);

        std::vector<uint32> textPixels;
        nuint textHeight;
        nuint sourceTextWidth;

        struct CharacterRenderListEntry
        {
            nuint CharacterIndex;
            nuint X;
            nuint Y;
            uint32 Color;
        };
        nuint ComputeWrappedCharacterRendering(const FontCacheEntry &font, std::vector<CharacterRenderListEntry> &outRenderList);
        void ComputeUnboundedCharacterRendering(const FontCacheEntry &font, std::vector<CharacterRenderListEntry> &outRenderList, nuint &outTextWidth, nuint &outTextHeight);

        nuint textureWidth, textureHeight;

        Texture2D texture;
        VertexBuffer vb;
        InterleavedVertexFormat vbFormat;
        void InitGL();
        void SetVB(float leftX, float bottomY);

        float renderUMin, renderUMax;
        float renderVMin, renderVMax;
        nuint renderWidth, renderHeight;

        inline nuint GetActualViewHeight() const
        {
            nuint actualViewHeight=ViewWindowHeight;

            if (actualViewHeight==0)
                actualViewHeight=GetTextHeight();

            if (actualViewHeight>GetTextHeight())
                actualViewHeight=GetTextHeight();

            return actualViewHeight;
        }

        std::vector<uint32> texturePixels; //temporary cache during CreateTexture, doesn't need persisted
    };
}

#endif //#ifdef GFX_USES_IMAGEMAGICK

#endif //#ifdef MPMA_COMPILE_GFX