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;

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

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

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

    RV_VKImage *myAtlasTexture;

    UT_UniquePtr<RV_Geometry> myGeometry;

    int myNumVertices;
};

///  A single text entry to be rendered
struct RV_API RV_TextEntry
{
    RV_TextEntry() = default;
    RV_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;
};

/// 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);

    UT_Array<RV_TextEntry> myTextEntries;
    UT_Array<RV_TextDeferData> myDeferData;
    UT_DimRect myViewport;
    bool myIsBuilding;
    bool myEnableBlending;
    bool myPreserveDepthState;
};

#endif