RV_TextRender.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_TextRender.h ( RV Library, C++)
 *
 */

#ifndef RV_TextRender_h
#define RV_TextRender_h

#include "RV_API.h"
#include "RV_TypePtrs.h"

#include <UT/UT_Array.h>
#include <UT/UT_Color.h>
#include <UT/UT_Rect.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector2.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>

class RE_Font;
class RV_Geometry;
class RV_Instance;
class RV_Render;
class RV_ShaderProgram;
class RV_ShaderVariableSet;
class RV_VKImage;


/// Vulkan text rendering class for viewport UI elements.
class RV_API RV_TextRender
{
public:
    RV_TextRender();
    ~RV_TextRender();

    RV_TextRender(const RV_TextRender &) = delete;
    RV_TextRender &operator=(const RV_TextRender &) = delete;

    /// Initialize text rendering with the given viewport. Clears any existing
    /// text entries.
    void beginText(RV_Render *r, const UT_DimRect &viewport);

    /// Add a text string to be rendered with the given font, position, and
    /// color.
    void addText(
            const char *text,
            RE_Font &font,
            fpreal32 x,
            fpreal32 y,
            const UT_Color &color,
            fpreal32 alpha = 1.0f);

    /// Add a text string to be rendered with the given font, position, depth,
    /// and color.
    void addText(
            const char *text,
            RE_Font &font,
            fpreal32 x,
            fpreal32 y,
            fpreal32 z,
            const UT_Color &color,
            fpreal32 alpha = 1.0f);

    /// Build the geometry and texture data needed for rendering. Needs to be
    /// called after beginText() and before render().
    void endText();

    /// Render the text
    void render(RV_Render *r);

    void render(RV_Render *r, const UT_DimRect &viewport);

    void render(RV_Render *r, const UT_Matrix4F &proj);

    /// Clear the text entries
    void clear();

    void setEnableBlending(bool val) { myEnableBlending = val; }
    void setPreserveDepthState(bool val) { myPreserveDepthState = val; }

    /// Check if there is any text to render.
    bool hasText() const { return !myTextEntries.isEmpty(); }

    /// Get the number of text entries awaiting rendering
    int numEntries() const { return myTextEntries.entries(); }

    /// Render text directly. This should be used for simple single-string
    /// rendering as it does not batch render calls.

    static void renderText(
            RV_Render *r,
            RE_Font &font,
            const char *text,
            fpreal32 x,
            fpreal32 y,
            fpreal32 z,
            const UT_Color &color,
            fpreal32 alpha,
            const UT_DimRect &viewport);

    static void renderText(
            RV_Render *r,
            RE_Font &font,
            const char *text,
            fpreal32 x,
            fpreal32 y,
            const UT_Color &color,
            fpreal32 alpha,
            const UT_DimRect &viewport)
    {
        renderText(r, font, text, x, y, 0.0f, color, alpha, viewport);
    }

    /// Convienience function to render text with a soft shadow (1 px offset)
    static void renderTextWithShadow(
            RV_Render *r,
            RE_Font &font,
            const char *text,
            fpreal32 x,
            fpreal32 y,
            fpreal32 z,
            const UT_Color &text_color,
            const UT_Color &shadow_color,
            fpreal32 alpha_scale,
            const UT_DimRect &viewport);

    static void renderTextWithShadow(
            RV_Render *r,
            RE_Font &font,
            const char *text,
            fpreal32 x,
            fpreal32 y,
            const UT_Color &text_color,
            const UT_Color &shadow_color,
            fpreal32 alpha_scale,
            const UT_DimRect &viewport)
    {
        renderTextWithShadow(
                r, font, text, x, y, 0.0f, text_color, shadow_color,
                alpha_scale, viewport);
    }

    static void cleanup();

private:
    // Get or create the text rendering shader program if not initialized.
    static RV_ShaderProgram *getTextShader(RV_Instance *inst);

    // Build the geometry from accumulated text entries
    void buildGeometry(RV_Render *r);

    //  A single text entry to be rendered
    struct TextEntry
    {
        TextEntry() = default;
        TextEntry(
            const UT_StringHolder &text,
            RE_Font *font,
            const UT_Vector3F &position,
            const UT_Color &color,
            fpreal32 alpha = 1.0f);

        UT_StringHolder myText;
        RE_Font *myFont = nullptr;
        UT_Vector3F myPosition;
        UT_Color myColor;
        fpreal32 myAlpha = 1.0f;
    };
    UT_Array<TextEntry> myTextEntries;

    // Text data for rendering
    class TextDeferData
    {
    public:
        TextDeferData();
        ~TextDeferData();

        TextDeferData(TextDeferData &&other) noexcept;
        TextDeferData &operator=(TextDeferData &&other) noexcept;

        TextDeferData(const TextDeferData &) = delete;
        TextDeferData &operator=(const TextDeferData &) = delete;

        RV_VKImage *myAtlasTexture;

        UT_UniquePtr<RV_Geometry> myGeometry;

        int myNumVertices;
    };
    UT_Array<TextDeferData> myDeferData;
    
    UT_DimRect myViewport;
    bool myIsBuilding;
    bool myEnableBlending;
    bool myPreserveDepthState;
};

#endif