Implementation of slug text rendering.

Author: jasonbeverage

src/applications/CMakeLists.txt

@@ -64,6 +64,7 @@ if(NOT OSGEARTH_BUILD_PLATFORM_IPHONE)
         add_subdirectory(osgearth_infinitescroll)
         add_subdirectory(osgearth_video)
         add_subdirectory(osgearth_heatmap)
+        add_subdirectory(osgearth_slugtext)
 
         if(OSGEARTH_BUILD_LEGACY_CONTROLS_API)
             add_subdirectory(osgearth_cluster)

src/applications/osgearth_slugtext/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_osgearth_app(
+    TARGET osgearth_slugtext
+    SOURCES osgearth_slugtext.cpp
+    FOLDER Examples)

src/applications/osgearth_slugtext/osgearth_slugtext.cpp

@@ -0,0 +1,133 @@
+/* osgEarth
+ * Copyright 2025 Pelican Mapping
+ * MIT License
+ */
+
+// Demo application for SlugText rendering.
+// Renders text using the Slug algorithm (Lengyel 2017) which produces
+// pixel-accurate results at any scale, rotation, or perspective.
+//
+// Usage: osgearth_slugtext [--font <path>] [--text <string>]
+
+#include <osgViewer/Viewer>
+#include <osgEarth/SlugText>
+#include <osgEarth/GLUtils>
+#include <osg/MatrixTransform>
+#include <osg/Camera>
+#include <iostream>
+
+using namespace osgEarth;
+
+int usage(const char* name, const char* msg)
+{
+    std::cerr << "Error: " << msg << std::endl;
+    std::cerr << "Usage: " << name << " [--font <path.ttf>] [--text <string>]" << std::endl;
+    return -1;
+}
+
+osg::Camera* createHUDCamera(int width, int height)
+{
+    osg::Camera* camera = new osg::Camera();
+    camera->setProjectionMatrix(osg::Matrix::ortho2D(0, width, 0, height));
+    camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
+    camera->setViewMatrix(osg::Matrix::identity());
+    camera->setClearMask(GL_DEPTH_BUFFER_BIT);
+    camera->setRenderOrder(osg::Camera::POST_RENDER);
+    camera->setAllowEventFocus(false);
+    return camera;
+}
+
+int main(int argc, char** argv)
+{
+    osg::ArgumentParser arguments(&argc, argv);
+    osgEarth::initialize(arguments);
+
+    std::string fontPath;
+    if (!arguments.read("--font", fontPath))
+    {
+        // Try common font paths
+#ifdef _WIN32
+        fontPath = "C:/Windows/Fonts/arial.ttf";
+#elif __APPLE__
+        fontPath = "/Library/Fonts/Arial.ttf";
+#else
+        fontPath = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
+#endif
+    }
+
+    std::string text;
+    if (!arguments.read("--text", text))
+    {
+        text = "Hello, Slug!";
+    }
+
+    osgViewer::Viewer viewer(arguments);
+
+    int width = 1280, height = 720;
+    osg::Group* root = new osg::Group();
+
+    // Create an orthographic HUD camera for 2D text display
+    osg::Camera* hud = createHUDCamera(width, height);
+    root->addChild(hud);
+
+    // Large text
+    {
+        auto* mt = new osg::MatrixTransform();
+        mt->setMatrix(osg::Matrix::translate(50, height - 100, 0));
+        auto* st = new SlugText(text, fontPath, 48.0f);
+        st->setColor(osg::Vec4(1, 1, 1, 1));
+        mt->addChild(st);
+        hud->addChild(mt);
+    }
+
+    // Medium text
+    {
+        auto* mt = new osg::MatrixTransform();
+        mt->setMatrix(osg::Matrix::translate(50, height - 180, 0));
+        auto* st = new SlugText("Resolution Independent Text", fontPath, 32.0f);
+        st->setColor(osg::Vec4(0.8f, 0.9f, 1.0f, 1.0f));
+        mt->addChild(st);
+        hud->addChild(mt);
+    }
+
+    // Small text
+    {
+        auto* mt = new osg::MatrixTransform();
+        mt->setMatrix(osg::Matrix::translate(50, height - 240, 0));
+        auto* st = new SlugText("Pixel Perfect at Any Scale", fontPath, 16.0f);
+        st->setColor(osg::Vec4(1.0f, 0.9f, 0.7f, 1.0f));
+        mt->addChild(st);
+        hud->addChild(mt);
+    }
+
+    // 3D perspective text (rotated)
+    {
+        auto* mt = new osg::MatrixTransform();
+        osg::Matrix m;
+        m.makeRotate(osg::DegreesToRadians(15.0), osg::Vec3(0, 0, 1));
+        m.setTrans(osg::Vec3(50, height - 350, 0));
+        mt->setMatrix(m);
+        auto* st = new SlugText("Rotated Text", fontPath, 36.0f);
+        st->setColor(osg::Vec4(0.5f, 1.0f, 0.5f, 1.0f));
+        mt->addChild(st);
+        hud->addChild(mt);
+    }
+
+    // Very large text to show resolution independence
+    {
+        auto* mt = new osg::MatrixTransform();
+        mt->setMatrix(osg::Matrix::translate(50, 80, 0));
+        auto* st = new SlugText("BIG", fontPath, 200.0f);
+        st->setColor(osg::Vec4(1.0f, 0.5f, 0.3f, 0.5f));
+        mt->addChild(st);
+        hud->addChild(mt);
+    }
+
+    viewer.setSceneData(root);
+
+#ifndef OSG_GL3_AVAILABLE
+    viewer.setRealizeOperation(new osgEarth::GL3RealizeOperation());
+#endif
+
+    return viewer.run();
+}

src/osgEarth/CMakeLists.txt

@@ -12,6 +12,7 @@ find_package(GDAL REQUIRED)
 find_package(SQLite3 REQUIRED)
 
 # optional
+find_package(Freetype QUIET)
 find_package(geos QUIET)
 find_package(blend2d QUIET)
 find_package(spdlog QUIET)
@@ -79,6 +80,7 @@ set(TARGET_GLSL
     WireLines.glsl
     PhongLighting.glsl
     PointDrawable.glsl
+    SlugText.glsl
     Text.glsl
     Text_legacy.glsl
     ContourMap.glsl
@@ -383,6 +385,8 @@ SET(TARGET_H
     Skins
     Sky
     SkyView
+    SlugFont
+    SlugText
     SpatialReference
     StarData
     StateSetCache
@@ -727,6 +731,8 @@ set(TARGET_SRC
     Skins.cpp
     Sky.cpp
     SkyView.cpp
+    SlugFont.cpp
+    SlugText.cpp
     SpatialReference.cpp
     StateSetCache.cpp
     Status.cpp
@@ -887,6 +893,13 @@ if(blosc_FOUND)
     target_link_libraries(${LIB_NAME} PRIVATE blosc_${shared_or_static})
 endif()
 
+# FreeType (for SlugFont)
+if(FREETYPE_FOUND)
+    message(STATUS "Found FreeType")
+    target_include_directories(${LIB_NAME} PRIVATE ${FREETYPE_INCLUDE_DIRS})
+    target_link_libraries(${LIB_NAME} PRIVATE ${FREETYPE_LIBRARIES})
+endif()
+
 # GEOS support?
 if(geos_FOUND)
     message(STATUS "Found geos")

src/osgEarth/Shaders

@@ -32,6 +32,7 @@ namespace osgEarth { namespace Util
         std::string WireLines;
         std::string PointDrawable;
         std::string PhongLighting;
+        std::string SlugText;
         std::string Text, TextLegacy;
         std::string ContourMap;
         std::string GeodeticGraticule;

src/osgEarth/Shaders.cpp.in

@@ -80,6 +80,10 @@ namespace osgEarth { namespace Util
         PhongLighting = "PhongLighting.glsl";
         _sources[PhongLighting] = @PhongLighting.glsl@;
 
+        // Slug Text
+        SlugText = "SlugText.glsl";
+        _sources[SlugText] = @SlugText.glsl@;
+
 		// Text
 		Text = "Text.glsl";
 		_sources[Text] = @Text.glsl@;

src/osgEarth/SlugFont

@@ -0,0 +1,85 @@
+/* osgEarth
+ * Copyright 2025 Pelican Mapping
+ * MIT License
+ */
+#ifndef OSGEARTH_SLUG_FONT_H
+#define OSGEARTH_SLUG_FONT_H 1
+
+#include <osgEarth/Common>
+#include <osg/Referenced>
+#include <osg/Texture2D>
+#include <map>
+#include <vector>
+#include <string>
+#include <cstdint>
+
+namespace osgEarth
+{
+    /**
+     * Extracts quadratic Bezier glyph outlines from a TrueType font via FreeType
+     * and packs them into GPU textures for use with the Slug rendering algorithm
+     * (Lengyel 2017).
+     *
+     * Two textures are produced:
+     *  - Curve texture (RGBA16F): Bezier control points
+     *  - Band texture (RGBA16UI): Band headers and curve indices
+     */
+    class OSGEARTH_EXPORT SlugFont : public osg::Referenced
+    {
+    public:
+        SlugFont(const std::string& fontPath);
+
+        struct GlyphData
+        {
+            // Texture location of this glyph's band data
+            int bandTexX = 0, bandTexY = 0;
+            // Band max indexes (horizontal, vertical)
+            int bandMaxX = 0, bandMaxY = 0;
+            // Band transform: scale.xy, offset.xy
+            float bandScaleX = 0, bandScaleY = 0, bandOffsetX = 0, bandOffsetY = 0;
+            // Glyph metrics (in em units, normalized to [0,1])
+            float bearingX = 0, bearingY = 0, width = 0, height = 0, advance = 0;
+        };
+
+        const GlyphData* getGlyph(uint32_t codepoint) const;
+        osg::Texture2D* getCurveTexture() const { return _curveTexture.get(); }
+        osg::Texture2D* getBandTexture() const { return _bandTexture.get(); }
+        bool valid() const { return _valid; }
+
+        static osg::ref_ptr<SlugFont> get(const std::string& fontPath);
+
+        struct CurveData {
+            float x1, y1, x2, y2, x3, y3;
+        };
+
+    protected:
+        virtual ~SlugFont();
+
+    private:
+        void load(const std::string& fontPath);
+        void processGlyph(void* face, uint32_t codepoint);
+        void buildTextures();
+
+        struct BandEntry {
+            int curveCount;
+            std::vector<int> curveIndices;
+        };
+
+        struct GlyphBuildData {
+            GlyphData metrics;
+            std::vector<CurveData> curves;
+            std::vector<BandEntry> hbands;
+            std::vector<BandEntry> vbands;
+        };
+
+        std::map<uint32_t, GlyphBuildData> _glyphBuild;
+        std::map<uint32_t, GlyphData> _glyphs;
+        osg::ref_ptr<osg::Texture2D> _curveTexture;
+        osg::ref_ptr<osg::Texture2D> _bandTexture;
+        bool _valid;
+
+        static const int BAND_TEX_WIDTH = 4096;
+    };
+}
+
+#endif // OSGEARTH_SLUG_FONT_H