From bbefd8366497d906887f3dd0f0ef8d7273148af1 Mon Sep 17 00:00:00 2001 From: ChestnutYueyue <952134128@qq.com> Date: Mon, 23 Feb 2026 21:30:44 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0MSDF=E5=AD=97?= =?UTF-8?q?=E4=BD=93=E6=94=AF=E6=8C=81=E5=B9=B6=E9=87=8D=E6=9E=84=E6=96=87?= =?UTF-8?q?=E6=9C=AC=E6=B8=B2=E6=9F=93=E7=B3=BB=E7=BB=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 实现MSDF字体渲染功能，包括： 1. 新增MSDF字体构建工具，支持从TTF生成MSDF图集 2. 重构字体加载器和文本渲染器以支持MSDF 3. 添加MSDF文本渲染示例程序 4. 移除旧的TrueType字体渲染实现 5. 优化VAO顶点属性绑定设置 MSDF字体提供高质量的可缩放文本渲染，同时保持运行时性能。构建工具将TTF转换为带元数据的PNG图集，运行时只需加载预生成的纹理。重构后的文本渲染系统更简洁高效，支持中文等复杂字符集。 --- Extra2D/include/extra2d/asset/asset_loader.h | 33 +- Extra2D/include/extra2d/asset/font_asset.h | 171 +- .../include/extra2d/asset/msdf_font_asset.h | 184 - .../include/extra2d/asset/msdf_font_loader.h | 41 - .../extra2d/render/msdf_text_renderer.h | 118 - .../include/extra2d/render/text_renderer.h | 59 +- .../include/extra2d/services/render_service.h | 375 ++ Extra2D/include/stb/stb_image_write.h | 1724 ++++++ Extra2D/include/stb/stb_rect_pack.h | 623 -- Extra2D/include/stb/stb_truetype.h | 5079 ----------------- Extra2D/src/asset/asset_loader.cpp | 175 +- Extra2D/src/asset/font_asset.cpp | 92 +- Extra2D/src/asset/msdf_font_asset.cpp | 87 - Extra2D/src/asset/msdf_font_loader.cpp | 183 - Extra2D/src/render/msdf_text_renderer.cpp | 217 - Extra2D/src/render/text_renderer.cpp | 74 +- Extra2D/src/render/vao.cpp | 2 +- Extra2D/src/services/asset_service.cpp | 4 + Extra2D/src/services/render_service.cpp | 287 + examples/msdf_text_demo/main.cpp | 155 + .../romfs/assets/simhei.msdf.png | Bin 0 -> 608734 bytes examples/msdf_text_demo/xmake.lua | 75 + test_output.msdf.png | Bin 0 -> 608734 bytes tools/msdf_font_builder/README.md | 77 + tools/msdf_font_builder/charset_default.txt | 5 + tools/msdf_font_builder/main.cpp | 100 + tools/msdf_font_builder/msdf_font_builder.cpp | 588 ++ tools/msdf_font_builder/msdf_font_builder.h | 143 + xmake.lua | 12 +- 29 files changed, 3964 insertions(+), 6719 deletions(-) delete mode 100644 Extra2D/include/extra2d/asset/msdf_font_asset.h delete mode 100644 Extra2D/include/extra2d/asset/msdf_font_loader.h delete mode 100644 Extra2D/include/extra2d/render/msdf_text_renderer.h create mode 100644 Extra2D/include/extra2d/services/render_service.h create mode 100644 Extra2D/include/stb/stb_image_write.h delete mode 100644 Extra2D/include/stb/stb_rect_pack.h delete mode 100644 Extra2D/include/stb/stb_truetype.h delete mode 100644 Extra2D/src/asset/msdf_font_asset.cpp delete mode 100644 Extra2D/src/asset/msdf_font_loader.cpp delete mode 100644 Extra2D/src/render/msdf_text_renderer.cpp create mode 100644 Extra2D/src/services/render_service.cpp create mode 100644 examples/msdf_text_demo/main.cpp create mode 100644 examples/msdf_text_demo/romfs/assets/simhei.msdf.png create mode 100644 examples/msdf_text_demo/xmake.lua create mode 100644 test_output.msdf.png create mode 100644 tools/msdf_font_builder/README.md create mode 100644 tools/msdf_font_builder/charset_default.txt create mode 100644 tools/msdf_font_builder/main.cpp create mode 100644 tools/msdf_font_builder/msdf_font_builder.cpp create mode 100644 tools/msdf_font_builder/msdf_font_builder.h diff --git a/Extra2D/include/extra2d/asset/asset_loader.h b/Extra2D/include/extra2d/asset/asset_loader.h index c26bf9f..62f509d 100644 --- a/Extra2D/include/extra2d/asset/asset_loader.h +++ b/Extra2D/include/extra2d/asset/asset_loader.h @@ -142,21 +142,40 @@ private: }; // --------------------------------------------------------------------------- -// FontLoader - 字体加载器 +// FontLoader - 字体加载器 (MSDF) // --------------------------------------------------------------------------- /** * @brief 字体加载器 * - * 加载 TrueType 字体文件（.ttf, .otf）。 + * 加载内嵌元数据的 MSDF PNG 图集。 + * 构建时使用 msdfgen 生成图集，运行时只加载预生成的 PNG。 */ class FontLoader : public AssetLoader { public: - Ref load(const std::string &path) override; - Ref loadFromMemory(const u8 *data, size_t size) override; - bool canLoad(const std::string &path) const override; - AssetType type() const override { return AssetType::Font; } - std::vector extensions() const override; + Ref load(const std::string &path) override; + Ref loadFromMemory(const u8 *data, size_t size) override; + bool canLoad(const std::string &path) const override; + AssetType type() const override { return AssetType::Font; } + std::vector extensions() const override; + +private: + /** + * @brief 解析 PNG 内嵌元数据 + */ + bool parseEmbeddedMetadata(const std::string &path, FontAsset *asset); + + /** + * @brief 从 tEXt chunk 读取数据 + */ + bool readTextChunk(const std::vector &pngData, + const std::string &keyword, + std::vector &output); + + /** + * @brief 解析 JSON 元数据 + */ + bool parseJsonMetadata(const std::string &json, FontAsset *asset); }; // --------------------------------------------------------------------------- diff --git a/Extra2D/include/extra2d/asset/font_asset.h b/Extra2D/include/extra2d/asset/font_asset.h index 307fac1..0e3f78b 100644 --- a/Extra2D/include/extra2d/asset/font_asset.h +++ b/Extra2D/include/extra2d/asset/font_asset.h @@ -1,15 +1,32 @@ #pragma once #include +#include +#include +#include +#include #include +#include namespace extra2d { /** - * @brief 字体资源类 + * @brief 字符信息 + */ +struct GlyphInfo { + char32_t codepoint = 0; ///< Unicode 码点 + glm::vec2 uvMin; ///< UV 左下角 + glm::vec2 uvMax; ///< UV 右上角 + glm::vec2 size; ///< 字符尺寸（像素） + glm::vec2 bearing; ///< 基线偏移 + float advance = 0.0f; ///< 前进宽度 +}; + +/** + * @brief MSDF 字体资源 * - * 存储TrueType字体数据，支持字形渲染。 - * 使用 Pimpl 模式隐藏 stbtt_fontinfo 实现细节。 + * 加载内嵌元数据的 MSDF PNG 图集。 + * 构建时使用 msdfgen 生成图集，运行时只加载预生成的 PNG。 */ class FontAsset : public Asset { public: @@ -17,46 +34,152 @@ public: ~FontAsset() override; AssetType type() const override { return AssetType::Font; } - bool loaded() const override; - - size_t memSize() const override { return data_.size(); } + size_t memSize() const override; /** - * @brief 获取指定像素高度的缩放因子 - * @param pixels 像素高度 - * @return 缩放因子 + * @brief 获取图集纹理 ID + * @return OpenGL 纹理 ID */ - float scaleForPixelHeight(float pixels) const; + GLuint textureId() const { return textureId_; } /** - * @brief 获取字体数据 - * @return 字体数据指针 + * @brief 获取字符信息 + * @param codepoint Unicode 码点 + * @return 字符信息指针，不存在返回 nullptr */ - const u8 *data() const { return data_.data(); } + const GlyphInfo* getGlyph(char32_t codepoint) const; /** - * @brief 获取字体数据大小 - * @return 数据大小（字节） + * @brief 检查是否有字符 + * @param codepoint Unicode 码点 + * @return 存在返回 true */ - size_t dataSize() const { return data_.size(); } + bool hasGlyph(char32_t codepoint) const; /** - * @brief 设置字体数据 - * @param data 字体数据 - * @return 成功返回 true + * @brief 获取缺失的字符列表 + * @param text 文本 + * @return 缺失字符列表 */ - bool setData(std::vector data); + std::vector getMissingChars(const std::u32string& text) const; /** - * @brief 释放字体数据 + * @brief 检查文本是否可渲染 + * @param text 文本 + * @return 可渲染返回 true + */ + bool canRender(const std::u32string& text) const; + + /** + * @brief 计算文本尺寸 + * @param text 文本 + * @param scale 缩放比例 + * @return 文本尺寸 + */ + glm::vec2 measureText(const std::u32string& text, float scale = 1.0f) const; + + /** + * @brief 获取字体大小 + * @return 字体大小（像素） + */ + int fontSize() const { return fontSize_; } + + /** + * @brief 获取像素范围 + * @return 像素范围 + */ + float pxRange() const { return pxRange_; } + + /** + * @brief 获取图集宽度 + * @return 宽度 + */ + int atlasWidth() const { return atlasWidth_; } + + /** + * @brief 获取图集高度 + * @return 高度 + */ + int atlasHeight() const { return atlasHeight_; } + + /** + * @brief 获取行高 + * @return 行高 + */ + int lineHeight() const { return lineHeight_; } + + /** + * @brief 获取基线 + * @return 基线 + */ + int baseline() const { return baseline_; } + + /** + * @brief 设置纹理 ID + * @param id 纹理 ID + */ + void setTextureId(GLuint id) { textureId_ = id; } + + /** + * @brief 设置字体大小 + * @param size 字体大小 + */ + void setFontSize(int size) { fontSize_ = size; } + + /** + * @brief 设置像素范围 + * @param range 像素范围 + */ + void setPxRange(float range) { pxRange_ = range; } + + /** + * @brief 设置图集尺寸 + * @param width 宽度 + * @param height 高度 + */ + void setAtlasSize(int width, int height) { + atlasWidth_ = width; + atlasHeight_ = height; + } + + /** + * @brief 设置行高 + * @param height 行高 + */ + void setLineHeight(int height) { lineHeight_ = height; } + + /** + * @brief 设置基线 + * @param baseline 基线 + */ + void setBaseline(int baseline) { baseline_ = baseline; } + + /** + * @brief 添加字符信息 + * @param glyph 字符信息 + */ + void addGlyph(const GlyphInfo& glyph); + + /** + * @brief 标记为已加载 + */ + void markLoaded(); + + /** + * @brief 释放资源 */ void release(); private: - std::vector data_; - class Impl; - Unique impl_; + GLuint textureId_ = 0; + int fontSize_ = 48; + float pxRange_ = 4.0f; + int atlasWidth_ = 2048; + int atlasHeight_ = 2048; + int lineHeight_ = 60; + int baseline_ = 12; + std::unordered_map glyphs_; }; } // namespace extra2d diff --git a/Extra2D/include/extra2d/asset/msdf_font_asset.h b/Extra2D/include/extra2d/asset/msdf_font_asset.h deleted file mode 100644 index 109403f..0000000 --- a/Extra2D/include/extra2d/asset/msdf_font_asset.h +++ /dev/null @@ -1,184 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include - -namespace extra2d { - -/** - * @brief 字符信息 - */ -struct GlyphInfo { - char32_t codepoint = 0; ///< Unicode 码点 - glm::vec2 uvMin; ///< UV 左下角 - glm::vec2 uvMax; ///< UV 右上角 - glm::vec2 size; ///< 字符尺寸（像素） - glm::vec2 bearing; ///< 基线偏移 - float advance = 0.0f; ///< 前进宽度 -}; - -/** - * @brief MSDF 字体资源 - * - * 加载内嵌元数据的 MSDF PNG 图集 - */ -class MSDFFontAsset : public Asset { -public: - MSDFFontAsset(); - ~MSDFFontAsset() override; - - AssetType type() const override { return AssetType::Font; } - bool loaded() const override; - size_t memSize() const override; - - /** - * @brief 获取图集纹理 ID - * @return OpenGL 纹理 ID - */ - GLuint textureId() const { return textureId_; } - - /** - * @brief 获取字符信息 - * @param codepoint Unicode 码点 - * @return 字符信息指针，不存在返回 nullptr - */ - const GlyphInfo* getGlyph(char32_t codepoint) const; - - /** - * @brief 检查是否有字符 - * @param codepoint Unicode 码点 - * @return 存在返回 true - */ - bool hasGlyph(char32_t codepoint) const; - - /** - * @brief 获取缺失的字符列表 - * @param text 文本 - * @return 缺失字符列表 - */ - std::vector getMissingChars(const std::u32string& text) const; - - /** - * @brief 检查文本是否可渲染 - * @param text 文本 - * @return 可渲染返回 true - */ - bool canRender(const std::u32string& text) const; - - /** - * @brief 计算文本尺寸 - * @param text 文本 - * @param scale 缩放比例 - * @return 文本尺寸 - */ - glm::vec2 measureText(const std::u32string& text, float scale = 1.0f) const; - - /** - * @brief 获取字体大小 - * @return 字体大小（像素） - */ - int fontSize() const { return fontSize_; } - - /** - * @brief 获取像素范围 - * @return 像素范围 - */ - float pxRange() const { return pxRange_; } - - /** - * @brief 获取图集宽度 - * @return 宽度 - */ - int atlasWidth() const { return atlasWidth_; } - - /** - * @brief 获取图集高度 - * @return 高度 - */ - int atlasHeight() const { return atlasHeight_; } - - /** - * @brief 获取行高 - * @return 行高 - */ - int lineHeight() const { return lineHeight_; } - - /** - * @brief 获取基线 - * @return 基线 - */ - int baseline() const { return baseline_; } - - /** - * @brief 设置纹理 ID - * @param id 纹理 ID - */ - void setTextureId(GLuint id) { textureId_ = id; } - - /** - * @brief 设置字体大小 - * @param size 字体大小 - */ - void setFontSize(int size) { fontSize_ = size; } - - /** - * @brief 设置像素范围 - * @param range 像素范围 - */ - void setPxRange(float range) { pxRange_ = range; } - - /** - * @brief 设置图集尺寸 - * @param width 宽度 - * @param height 高度 - */ - void setAtlasSize(int width, int height) { - atlasWidth_ = width; - atlasHeight_ = height; - } - - /** - * @brief 设置行高 - * @param height 行高 - */ - void setLineHeight(int height) { lineHeight_ = height; } - - /** - * @brief 设置基线 - * @param baseline 基线 - */ - void setBaseline(int baseline) { baseline_ = baseline; } - - /** - * @brief 添加字符信息 - * @param glyph 字符信息 - */ - void addGlyph(const GlyphInfo& glyph); - - /** - * @brief 标记为已加载 - */ - void markLoaded(); - - /** - * @brief 释放资源 - */ - void release(); - -private: - GLuint textureId_ = 0; - int fontSize_ = 48; - float pxRange_ = 4.0f; - int atlasWidth_ = 2048; - int atlasHeight_ = 2048; - int lineHeight_ = 60; - int baseline_ = 12; - std::unordered_map glyphs_; -}; - -} // namespace extra2d diff --git a/Extra2D/include/extra2d/asset/msdf_font_loader.h b/Extra2D/include/extra2d/asset/msdf_font_loader.h deleted file mode 100644 index 065d7a3..0000000 --- a/Extra2D/include/extra2d/asset/msdf_font_loader.h +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace extra2d { - -/** - * @brief MSDF 字体加载器 - * - * 加载内嵌元数据的 MSDF PNG 图集 - */ -class MSDFFontLoader : public AssetLoader { -public: - Ref load(const std::string& path) override; - Ref loadFromMemory(const u8* data, size_t size) override; - bool canLoad(const std::string& path) const override; - AssetType type() const override { return AssetType::Font; } - std::vector extensions() const override; - -private: - /** - * @brief 解析 PNG 内嵌元数据 - */ - bool parseEmbeddedMetadata(const std::string& path, MSDFFontAsset* asset); - - /** - * @brief 从 tEXt chunk 读取数据 - */ - bool readTextChunk(const std::vector& pngData, - const std::string& keyword, - std::vector& output); - - /** - * @brief 解析 JSON 元数据 - */ - bool parseJsonMetadata(const std::string& json, MSDFFontAsset* asset); -}; - -} // namespace extra2d diff --git a/Extra2D/include/extra2d/render/msdf_text_renderer.h b/Extra2D/include/extra2d/render/msdf_text_renderer.h deleted file mode 100644 index 118c793..0000000 --- a/Extra2D/include/extra2d/render/msdf_text_renderer.h +++ /dev/null @@ -1,118 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -namespace extra2d { - -/** - * @brief MSDF 文本渲染器 - * - * 支持任意大小的字体渲染 - */ -class MSDFTextRenderer { -public: - MSDFTextRenderer(); - ~MSDFTextRenderer(); - - /** - * @brief 初始化 - * @return 成功返回 true - */ - bool init(); - - /** - * @brief 关闭 - */ - void shutdown(); - - /** - * @brief 设置字体 - * @param font 字体资源 - */ - void setFont(Ref font) { font_ = font; } - - /** - * @brief 获取字体 - * @return 字体资源 - */ - Ref font() const { return font_; } - - /** - * @brief 设置文本 - * @param text UTF-32 文本 - */ - void setText(const std::u32string& text) { text_ = text; } - - /** - * @brief 设置文本（UTF-8） - * @param utf8Text UTF-8 文本 - */ - void setText(const std::string& utf8Text); - - /** - * @brief 设置位置 - * @param pos 位置 - */ - void setPosition(const glm::vec2& pos) { position_ = pos; } - - /** - * @brief 设置字体大小 - * @param size 目标像素高度 - */ - void setFontSize(float size); - - /** - * @brief 设置颜色 - * @param color 颜色 - */ - void setColor(const Color& color) { color_ = color; } - - /** - * @brief 设置材质 - * @param material 材质实例 - */ - void setMaterial(Ref material) { material_ = material; } - - /** - * @brief 获取文本尺寸 - * @return 尺寸 - */ - glm::vec2 getSize() const; - - /** - * @brief 渲染 - * @param projection 投影矩阵 - */ - void render(const glm::mat4& projection); - -private: - Ref font_; - std::u32string text_; - glm::vec2 position_ = glm::vec2(0.0f); - float fontSize_ = 48.0f; - float scale_ = 1.0f; - Color color_ = Colors::White; - Ref material_; - - struct Vertex { - glm::vec2 position; - glm::vec2 texCoord; - }; - std::vector vertices_; - std::vector indices_; - - GLuint vao_ = 0; - GLuint vbo_ = 0; - GLuint ibo_ = 0; - GLuint shader_ = 0; - - void updateGeometry(); - void draw(); - bool createShader(); -}; - -} // namespace extra2d diff --git a/Extra2D/include/extra2d/render/text_renderer.h b/Extra2D/include/extra2d/render/text_renderer.h index 0bb269e..a225052 100644 --- a/Extra2D/include/extra2d/render/text_renderer.h +++ b/Extra2D/include/extra2d/render/text_renderer.h @@ -1,57 +1,19 @@ #pragma once +#include #include #include #include #include +#include #include #include #include #include #include -#include namespace extra2d { -/** - * @brief 字形信息 - */ -struct GlyphInfo { - char32_t codepoint = 0; - glm::vec2 uvMin = glm::vec2(0.0f); - glm::vec2 uvMax = glm::vec2(0.0f); - glm::vec2 size = glm::vec2(0.0f); - glm::vec2 bearing = glm::vec2(0.0f); - float advance = 0.0f; -}; - -/** - * @brief 字体图集 - */ -class FontAtlas { -public: - FontAtlas(); - ~FontAtlas(); - - bool create(int atlasWidth = 2048, int atlasHeight = 2048); - void destroy(); - - bool isValid() const { return texture_ != 0; } - GLuint texture() const { return texture_; } - int width() const { return width_; } - int height() const { return height_; } - - void addGlyph(char32_t codepoint, const GlyphInfo& info); - const GlyphInfo* getGlyph(char32_t codepoint) const; - bool hasGlyph(char32_t codepoint) const; - -private: - GLuint texture_ = 0; - int width_ = 0; - int height_ = 0; - std::unordered_map glyphs_; -}; - /** * @brief 文本顶点 */ @@ -69,7 +31,6 @@ struct TextConfig { glm::vec4 color = glm::vec4(1.0f); float outlineWidth = 0.0f; glm::vec4 outlineColor = glm::vec4(0.0f); - float pxRange = 4.0f; }; /** @@ -80,8 +41,7 @@ struct TextConfig { class TextRenderer { public: static constexpr size_t MAX_VERTICES = 65536; - static constexpr size_t VERTICES_PER_CHAR = 4; - static constexpr size_t INDICES_PER_CHAR = 6; + static constexpr size_t VERTICES_PER_CHAR = 6; TextRenderer(); ~TextRenderer(); @@ -104,13 +64,13 @@ public: /** * @brief 绘制文本 */ - void drawText(FontAtlas* font, const String32& text, + void drawText(FontAsset* font, const String32& text, float x, float y, const TextConfig& config = {}); /** * @brief 测量文本尺寸 */ - glm::vec2 measureText(FontAtlas* font, const String32& text, float fontSize); + glm::vec2 measureText(FontAsset* font, const String32& text, float fontSize); /** * @brief 结束批量渲染 @@ -122,18 +82,23 @@ public: */ uint32 drawCalls() const { return drawCalls_; } + /** + * @brief 设置材质 + */ + void setMaterial(Ref material) { material_ = material; } + private: std::unique_ptr vao_; std::unique_ptr vbo_; - std::unique_ptr ibo_; Array vertices_; size_t vertexCount_ = 0; GLuint shader_ = 0; glm::mat4 viewProjection_; - FontAtlas* currentFont_ = nullptr; + FontAsset* currentFont_ = nullptr; uint32 drawCalls_ = 0; + Ref material_; bool createShader(); void flush(); diff --git a/Extra2D/include/extra2d/services/render_service.h b/Extra2D/include/extra2d/services/render_service.h new file mode 100644 index 0000000..a5f709d --- /dev/null +++ b/Extra2D/include/extra2d/services/render_service.h @@ -0,0 +1,375 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace extra2d { + +/** + * @brief 渲染服务统计信息 + * + * 扩展基础 RenderStats，增加帧率和性能统计 + */ +struct RenderServiceStats { + u32 drawCalls = 0; + u32 spriteCount = 0; + u32 textChars = 0; + u32 frameCount = 0; + f32 frameTime = 0.0f; + f32 fps = 0.0f; +}; + +/** + * @brief 渲染回调函数类型 + * @param renderService 渲染服务实例 + * @param dt 帧间隔时间 + */ +using RenderCallback = std::function; + +/** + * @brief 渲染服务接口 + * + * 提供统一的 2D 渲染 API，封装图形绘制、精灵绘制、文本绘制等功能。 + * 支持帧生命周期管理、渲染回调和渲染统计。 + */ +class IRenderService : public IService { +public: + virtual ~IRenderService() = default; + + /** + * @brief 设置渲染回调 + * @param callback 渲染回调函数 + */ + virtual void onRender(RenderCallback callback) = 0; + + /** + * @brief 设置清屏颜色 + * @param color 清屏颜色 + */ + virtual void setClearColor(const Color &color) = 0; + + /** + * @brief 开始帧渲染 + * @param clearColor 清屏颜色 + */ + virtual void beginFrame(const Color &clearColor = Colors::Black) = 0; + + /** + * @brief 结束帧渲染 + */ + virtual void endFrame() = 0; + + /** + * @brief 设置视图投影矩阵 + * @param viewProjection 视图投影矩阵 + */ + virtual void setViewProjection(const glm::mat4 &viewProjection) = 0; + + /** + * @brief 获取视图投影矩阵 + * @return 当前视图投影矩阵 + */ + virtual glm::mat4 viewProjection() const = 0; + + /** + * @brief 设置摄像机 + * @param camera 摄像机引用 + */ + virtual void setCamera(const Camera &camera) = 0; + + // ========================================================================= + // 图形绘制 API + // ========================================================================= + + /** + * @brief 绘制线条 + * @param start 起点 + * @param end 终点 + * @param color 颜色 + * @param width 线宽 + */ + virtual void drawLine(const Vec2 &start, const Vec2 &end, const Color &color, + float width = 1.0f) = 0; + + /** + * @brief 绘制矩形（描边） + * @param rect 矩形区域 + * @param color 颜色 + * @param width 线宽 + */ + virtual void drawRect(const Rect &rect, const Color &color, + float width = 1.0f) = 0; + + /** + * @brief 绘制矩形（填充） + * @param rect 矩形区域 + * @param color 颜色 + */ + virtual void fillRect(const Rect &rect, const Color &color) = 0; + + /** + * @brief 绘制圆形（描边） + * @param center 圆心 + * @param radius 半径 + * @param color 颜色 + * @param segments 分段数 + * @param width 线宽 + */ + virtual void drawCircle(const Vec2 ¢er, float radius, const Color &color, + int segments = 32, float width = 1.0f) = 0; + + /** + * @brief 绘制圆形（填充） + * @param center 圆心 + * @param radius 半径 + * @param color 颜色 + * @param segments 分段数 + */ + virtual void fillCircle(const Vec2 ¢er, float radius, const Color &color, + int segments = 32) = 0; + + /** + * @brief 绘制三角形（描边） + */ + virtual void drawTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3, + const Color &color, float width = 1.0f) = 0; + + /** + * @brief 绘制三角形（填充） + */ + virtual void fillTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3, + const Color &color) = 0; + + /** + * @brief 绘制多边形（描边） + */ + virtual void drawPolygon(const std::vector &points, const Color &color, + float width = 1.0f) = 0; + + /** + * @brief 绘制多边形（填充） + */ + virtual void fillPolygon(const std::vector &points, + const Color &color) = 0; + + // ========================================================================= + // 精灵绘制 API + // ========================================================================= + + /** + * @brief 绘制精灵 + * @param texture 纹理 + * @param destRect 目标矩形 + * @param srcRect 源矩形 + * @param color 颜色 + * @param rotation 旋转角度 + * @param anchor 锚点 + */ + virtual void drawSprite(const Texture &texture, const Rect &destRect, + const Rect &srcRect, + const Color &color = Colors::White, + float rotation = 0.0f, + const Vec2 &anchor = Vec2(0.5f, 0.5f)) = 0; + + /** + * @brief 绘制精灵（简化版） + */ + virtual void drawSprite(const Texture &texture, const Vec2 &position, + const Color &color = Colors::White) = 0; + + /** + * @brief 绘制精灵（带缩放） + */ + virtual void drawSprite(const Texture &texture, const Vec2 &position, + const Vec2 &scale, + const Color &color = Colors::White) = 0; + + // ========================================================================= + // 文本绘制 API + // ========================================================================= + + /** + * @brief 绘制文本 + * @param font 字体资源 + * @param text 文本内容（UTF-32） + * @param x X 坐标 + * @param y Y 坐标 + * @param config 文本配置 + */ + virtual void drawText(FontAsset *font, const String32 &text, float x, float y, + const TextConfig &config = {}) = 0; + + /** + * @brief 绘制文本（UTF-8 字符串） + * @param font 字体资源 + * @param text 文本内容（UTF-8） + * @param x X 坐标 + * @param y Y 坐标 + * @param config 文本配置 + */ + virtual void drawText(FontAsset *font, const std::string &text, float x, + float y, const TextConfig &config = {}) = 0; + + /** + * @brief 测量文本尺寸 + * @param font 字体资源 + * @param text 文本内容 + * @param fontSize 字体大小 + * @return 文本尺寸 + */ + virtual glm::vec2 measureText(FontAsset *font, const String32 &text, + float fontSize) = 0; + + // ========================================================================= + // 统计信息 + // ========================================================================= + + /** + * @brief 获取渲染服务统计信息 + * @return 渲染统计 + */ + virtual RenderServiceStats stats() const = 0; + + /** + * @brief 重置渲染统计 + */ + virtual void resetStats() = 0; + + /** + * @brief 获取渲染设备 + * @return 渲染设备引用 + */ + virtual RenderDevice &device() = 0; + + /** + * @brief 获取底层渲染器 + * @return 渲染器指针 + */ + virtual Renderer *renderer() = 0; + + /** + * @brief 获取文本渲染器 + * @return 文本渲染器指针 + */ + virtual TextRenderer *textRenderer() = 0; +}; + +/** + * @brief 渲染服务实现 + * + * 封装 Renderer 和 TextRenderer，提供统一的渲染服务接口。 + * 依赖 RenderModule 和 ILogger 服务。 + * 支持渲染回调，自动管理帧生命周期。 + */ +class RenderService : public IRenderService { +public: + RenderService(); + ~RenderService() override; + + ServiceInfo info() const override { + ServiceInfo i; + i.name = "RenderService"; + i.priority = ServicePriority::Resource; + i.enabled = true; + return i; + } + + /** + * @brief 渲染服务依赖日志服务 + */ + std::vector deps() const override { + return {std::type_index(typeid(ILogger))}; + } + + /** + * @brief 渲染服务依赖渲染模块 + */ + std::vector needsModules() const override { + return {std::type_index(typeid(RenderModule))}; + } + + bool init() override; + void shutdown() override; + + void onRender(RenderCallback callback) override; + void setClearColor(const Color &color) override; + + void beginFrame(const Color &clearColor = Colors::Black) override; + void endFrame() override; + + void setViewProjection(const glm::mat4 &viewProjection) override; + glm::mat4 viewProjection() const override; + void setCamera(const Camera &camera) override; + + void drawLine(const Vec2 &start, const Vec2 &end, const Color &color, + float width = 1.0f) override; + void drawRect(const Rect &rect, const Color &color, + float width = 1.0f) override; + void fillRect(const Rect &rect, const Color &color) override; + void drawCircle(const Vec2 ¢er, float radius, const Color &color, + int segments = 32, float width = 1.0f) override; + void fillCircle(const Vec2 ¢er, float radius, const Color &color, + int segments = 32) override; + void drawTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3, + const Color &color, float width = 1.0f) override; + void fillTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3, + const Color &color) override; + void drawPolygon(const std::vector &points, const Color &color, + float width = 1.0f) override; + void fillPolygon(const std::vector &points, + const Color &color) override; + + void drawSprite(const Texture &texture, const Rect &destRect, + const Rect &srcRect, const Color &color = Colors::White, + float rotation = 0.0f, + const Vec2 &anchor = Vec2(0.5f, 0.5f)) override; + void drawSprite(const Texture &texture, const Vec2 &position, + const Color &color = Colors::White) override; + void drawSprite(const Texture &texture, const Vec2 &position, + const Vec2 &scale, + const Color &color = Colors::White) override; + + void drawText(FontAsset *font, const String32 &text, float x, float y, + const TextConfig &config = {}) override; + void drawText(FontAsset *font, const std::string &text, float x, float y, + const TextConfig &config = {}) override; + glm::vec2 measureText(FontAsset *font, const String32 &text, + float fontSize) override; + + RenderServiceStats stats() const override; + void resetStats() override; + + RenderDevice &device() override; + Renderer *renderer() override; + TextRenderer *textRenderer() override; + + void update(f32 dt) override; + +private: + std::unique_ptr renderer_; + std::unique_ptr textRenderer_; + RenderServiceStats stats_; + RenderCallback renderCallback_; + Color clearColor_{0.1f, 0.1f, 0.15f, 1.0f}; + bool inFrame_ = false; + f32 frameStartTime_ = 0.0f; + f32 fpsAccumulator_ = 0.0f; + u32 fpsFrameCount_ = 0; + + glm::vec4 toVec4(const Color &color) const; +}; + +} // namespace extra2d diff --git a/Extra2D/include/stb/stb_image_write.h b/Extra2D/include/stb/stb_image_write.h new file mode 100644 index 0000000..e4b32ed --- /dev/null +++ b/Extra2D/include/stb/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/Extra2D/include/stb/stb_rect_pack.h b/Extra2D/include/stb/stb_rect_pack.h deleted file mode 100644 index 6a633ce..0000000 --- a/Extra2D/include/stb/stb_rect_pack.h +++ /dev/null @@ -1,623 +0,0 @@ -// stb_rect_pack.h - v1.01 - public domain - rectangle packing -// Sean Barrett 2014 -// -// Useful for e.g. packing rectangular textures into an atlas. -// Does not do rotation. -// -// Before #including, -// -// #define STB_RECT_PACK_IMPLEMENTATION -// -// in the file that you want to have the implementation. -// -// Not necessarily the awesomest packing method, but better than -// the totally naive one in stb_truetype (which is primarily what -// this is meant to replace). -// -// Has only had a few tests run, may have issues. -// -// More docs to come. -// -// No memory allocations; uses qsort() and assert() from stdlib. -// Can override those by defining STBRP_SORT and STBRP_ASSERT. -// -// This library currently uses the Skyline Bottom-Left algorithm. -// -// Please note: better rectangle packers are welcome! Please -// implement them to the same API, but with a different init -// function. -// -// Credits -// -// Library -// Sean Barrett -// Minor features -// Martins Mozeiko -// github:IntellectualKitty -// -// Bugfixes / warning fixes -// Jeremy Jaussaud -// Fabian Giesen -// -// Version history: -// -// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section -// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles -// 0.99 (2019-02-07) warning fixes -// 0.11 (2017-03-03) return packing success/fail result -// 0.10 (2016-10-25) remove cast-away-const to avoid warnings -// 0.09 (2016-08-27) fix compiler warnings -// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) -// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) -// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort -// 0.05: added STBRP_ASSERT to allow replacing assert -// 0.04: fixed minor bug in STBRP_LARGE_RECTS support -// 0.01: initial release -// -// LICENSE -// -// See end of file for license information. - -////////////////////////////////////////////////////////////////////////////// -// -// INCLUDE SECTION -// - -#ifndef STB_INCLUDE_STB_RECT_PACK_H -#define STB_INCLUDE_STB_RECT_PACK_H - -#define STB_RECT_PACK_VERSION 1 - -#ifdef STBRP_STATIC -#define STBRP_DEF static -#else -#define STBRP_DEF extern -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct stbrp_context stbrp_context; -typedef struct stbrp_node stbrp_node; -typedef struct stbrp_rect stbrp_rect; - -typedef int stbrp_coord; - -#define STBRP__MAXVAL 0x7fffffff -// Mostly for internal use, but this is the maximum supported coordinate value. - -STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects); -// Assign packed locations to rectangles. The rectangles are of type -// 'stbrp_rect' defined below, stored in the array 'rects', and there -// are 'num_rects' many of them. -// -// Rectangles which are successfully packed have the 'was_packed' flag -// set to a non-zero value and 'x' and 'y' store the minimum location -// on each axis (i.e. bottom-left in cartesian coordinates, top-left -// if you imagine y increasing downwards). Rectangles which do not fit -// have the 'was_packed' flag set to 0. -// -// You should not try to access the 'rects' array from another thread -// while this function is running, as the function temporarily reorders -// the array while it executes. -// -// To pack into another rectangle, you need to call stbrp_init_target -// again. To continue packing into the same rectangle, you can call -// this function again. Calling this multiple times with multiple rect -// arrays will probably produce worse packing results than calling it -// a single time with the full rectangle array, but the option is -// available. -// -// The function returns 1 if all of the rectangles were successfully -// packed and 0 otherwise. - -struct stbrp_rect -{ - // reserved for your use: - int id; - - // input: - stbrp_coord w, h; - - // output: - stbrp_coord x, y; - int was_packed; // non-zero if valid packing - -}; // 16 bytes, nominally - - -STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes); -// Initialize a rectangle packer to: -// pack a rectangle that is 'width' by 'height' in dimensions -// using temporary storage provided by the array 'nodes', which is 'num_nodes' long -// -// You must call this function every time you start packing into a new target. -// -// There is no "shutdown" function. The 'nodes' memory must stay valid for -// the following stbrp_pack_rects() call (or calls), but can be freed after -// the call (or calls) finish. -// -// Note: to guarantee best results, either: -// 1. make sure 'num_nodes' >= 'width' -// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' -// -// If you don't do either of the above things, widths will be quantized to multiples -// of small integers to guarantee the algorithm doesn't run out of temporary storage. -// -// If you do #2, then the non-quantized algorithm will be used, but the algorithm -// may run out of temporary storage and be unable to pack some rectangles. - -STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem); -// Optionally call this function after init but before doing any packing to -// change the handling of the out-of-temp-memory scenario, described above. -// If you call init again, this will be reset to the default (false). - - -STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic); -// Optionally select which packing heuristic the library should use. Different -// heuristics will produce better/worse results for different data sets. -// If you call init again, this will be reset to the default. - -enum -{ - STBRP_HEURISTIC_Skyline_default=0, - STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default, - STBRP_HEURISTIC_Skyline_BF_sortHeight -}; - - -////////////////////////////////////////////////////////////////////////////// -// -// the details of the following structures don't matter to you, but they must -// be visible so you can handle the memory allocations for them - -struct stbrp_node -{ - stbrp_coord x,y; - stbrp_node *next; -}; - -struct stbrp_context -{ - int width; - int height; - int align; - int init_mode; - int heuristic; - int num_nodes; - stbrp_node *active_head; - stbrp_node *free_head; - stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' -}; - -#ifdef __cplusplus -} -#endif - -#endif - -////////////////////////////////////////////////////////////////////////////// -// -// IMPLEMENTATION SECTION -// - -#ifdef STB_RECT_PACK_IMPLEMENTATION -#ifndef STBRP_SORT -#include -#define STBRP_SORT qsort -#endif - -#ifndef STBRP_ASSERT -#include -#define STBRP_ASSERT assert -#endif - -#ifdef _MSC_VER -#define STBRP__NOTUSED(v) (void)(v) -#define STBRP__CDECL __cdecl -#else -#define STBRP__NOTUSED(v) (void)sizeof(v) -#define STBRP__CDECL -#endif - -enum -{ - STBRP__INIT_skyline = 1 -}; - -STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) -{ - switch (context->init_mode) { - case STBRP__INIT_skyline: - STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight); - context->heuristic = heuristic; - break; - default: - STBRP_ASSERT(0); - } -} - -STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) -{ - if (allow_out_of_mem) - // if it's ok to run out of memory, then don't bother aligning them; - // this gives better packing, but may fail due to OOM (even though - // the rectangles easily fit). @TODO a smarter approach would be to only - // quantize once we've hit OOM, then we could get rid of this parameter. - context->align = 1; - else { - // if it's not ok to run out of memory, then quantize the widths - // so that num_nodes is always enough nodes. - // - // I.e. num_nodes * align >= width - // align >= width / num_nodes - // align = ceil(width/num_nodes) - - context->align = (context->width + context->num_nodes-1) / context->num_nodes; - } -} - -STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes) -{ - int i; - - for (i=0; i < num_nodes-1; ++i) - nodes[i].next = &nodes[i+1]; - nodes[i].next = NULL; - context->init_mode = STBRP__INIT_skyline; - context->heuristic = STBRP_HEURISTIC_Skyline_default; - context->free_head = &nodes[0]; - context->active_head = &context->extra[0]; - context->width = width; - context->height = height; - context->num_nodes = num_nodes; - stbrp_setup_allow_out_of_mem(context, 0); - - // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) - context->extra[0].x = 0; - context->extra[0].y = 0; - context->extra[0].next = &context->extra[1]; - context->extra[1].x = (stbrp_coord) width; - context->extra[1].y = (1<<30); - context->extra[1].next = NULL; -} - -// find minimum y position if it starts at x1 -static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) -{ - stbrp_node *node = first; - int x1 = x0 + width; - int min_y, visited_width, waste_area; - - STBRP__NOTUSED(c); - - STBRP_ASSERT(first->x <= x0); - - #if 0 - // skip in case we're past the node - while (node->next->x <= x0) - ++node; - #else - STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency - #endif - - STBRP_ASSERT(node->x <= x0); - - min_y = 0; - waste_area = 0; - visited_width = 0; - while (node->x < x1) { - if (node->y > min_y) { - // raise min_y higher. - // we've accounted for all waste up to min_y, - // but we'll now add more waste for everything we've visted - waste_area += visited_width * (node->y - min_y); - min_y = node->y; - // the first time through, visited_width might be reduced - if (node->x < x0) - visited_width += node->next->x - x0; - else - visited_width += node->next->x - node->x; - } else { - // add waste area - int under_width = node->next->x - node->x; - if (under_width + visited_width > width) - under_width = width - visited_width; - waste_area += under_width * (min_y - node->y); - visited_width += under_width; - } - node = node->next; - } - - *pwaste = waste_area; - return min_y; -} - -typedef struct -{ - int x,y; - stbrp_node **prev_link; -} stbrp__findresult; - -static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height) -{ - int best_waste = (1<<30), best_x, best_y = (1 << 30); - stbrp__findresult fr; - stbrp_node **prev, *node, *tail, **best = NULL; - - // align to multiple of c->align - width = (width + c->align - 1); - width -= width % c->align; - STBRP_ASSERT(width % c->align == 0); - - // if it can't possibly fit, bail immediately - if (width > c->width || height > c->height) { - fr.prev_link = NULL; - fr.x = fr.y = 0; - return fr; - } - - node = c->active_head; - prev = &c->active_head; - while (node->x + width <= c->width) { - int y,waste; - y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste); - if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL - // bottom left - if (y < best_y) { - best_y = y; - best = prev; - } - } else { - // best-fit - if (y + height <= c->height) { - // can only use it if it first vertically - if (y < best_y || (y == best_y && waste < best_waste)) { - best_y = y; - best_waste = waste; - best = prev; - } - } - } - prev = &node->next; - node = node->next; - } - - best_x = (best == NULL) ? 0 : (*best)->x; - - // if doing best-fit (BF), we also have to try aligning right edge to each node position - // - // e.g, if fitting - // - // ____________________ - // |____________________| - // - // into - // - // | | - // | ____________| - // |____________| - // - // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned - // - // This makes BF take about 2x the time - - if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) { - tail = c->active_head; - node = c->active_head; - prev = &c->active_head; - // find first node that's admissible - while (tail->x < width) - tail = tail->next; - while (tail) { - int xpos = tail->x - width; - int y,waste; - STBRP_ASSERT(xpos >= 0); - // find the left position that matches this - while (node->next->x <= xpos) { - prev = &node->next; - node = node->next; - } - STBRP_ASSERT(node->next->x > xpos && node->x <= xpos); - y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste); - if (y + height <= c->height) { - if (y <= best_y) { - if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) { - best_x = xpos; - STBRP_ASSERT(y <= best_y); - best_y = y; - best_waste = waste; - best = prev; - } - } - } - tail = tail->next; - } - } - - fr.prev_link = best; - fr.x = best_x; - fr.y = best_y; - return fr; -} - -static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) -{ - // find best position according to heuristic - stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height); - stbrp_node *node, *cur; - - // bail if: - // 1. it failed - // 2. the best node doesn't fit (we don't always check this) - // 3. we're out of memory - if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) { - res.prev_link = NULL; - return res; - } - - // on success, create new node - node = context->free_head; - node->x = (stbrp_coord) res.x; - node->y = (stbrp_coord) (res.y + height); - - context->free_head = node->next; - - // insert the new node into the right starting point, and - // let 'cur' point to the remaining nodes needing to be - // stiched back in - - cur = *res.prev_link; - if (cur->x < res.x) { - // preserve the existing one, so start testing with the next one - stbrp_node *next = cur->next; - cur->next = node; - cur = next; - } else { - *res.prev_link = node; - } - - // from here, traverse cur and free the nodes, until we get to one - // that shouldn't be freed - while (cur->next && cur->next->x <= res.x + width) { - stbrp_node *next = cur->next; - // move the current node to the free list - cur->next = context->free_head; - context->free_head = cur; - cur = next; - } - - // stitch the list back in - node->next = cur; - - if (cur->x < res.x + width) - cur->x = (stbrp_coord) (res.x + width); - -#ifdef _DEBUG - cur = context->active_head; - while (cur->x < context->width) { - STBRP_ASSERT(cur->x < cur->next->x); - cur = cur->next; - } - STBRP_ASSERT(cur->next == NULL); - - { - int count=0; - cur = context->active_head; - while (cur) { - cur = cur->next; - ++count; - } - cur = context->free_head; - while (cur) { - cur = cur->next; - ++count; - } - STBRP_ASSERT(count == context->num_nodes+2); - } -#endif - - return res; -} - -static int STBRP__CDECL rect_height_compare(const void *a, const void *b) -{ - const stbrp_rect *p = (const stbrp_rect *) a; - const stbrp_rect *q = (const stbrp_rect *) b; - if (p->h > q->h) - return -1; - if (p->h < q->h) - return 1; - return (p->w > q->w) ? -1 : (p->w < q->w); -} - -static int STBRP__CDECL rect_original_order(const void *a, const void *b) -{ - const stbrp_rect *p = (const stbrp_rect *) a; - const stbrp_rect *q = (const stbrp_rect *) b; - return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed); -} - -STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) -{ - int i, all_rects_packed = 1; - - // we use the 'was_packed' field internally to allow sorting/unsorting - for (i=0; i < num_rects; ++i) { - rects[i].was_packed = i; - } - - // sort according to heuristic - STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare); - - for (i=0; i < num_rects; ++i) { - if (rects[i].w == 0 || rects[i].h == 0) { - rects[i].x = rects[i].y = 0; // empty rect needs no space - } else { - stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h); - if (fr.prev_link) { - rects[i].x = (stbrp_coord) fr.x; - rects[i].y = (stbrp_coord) fr.y; - } else { - rects[i].x = rects[i].y = STBRP__MAXVAL; - } - } - } - - // unsort - STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order); - - // set was_packed flags and all_rects_packed status - for (i=0; i < num_rects; ++i) { - rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL); - if (!rects[i].was_packed) - all_rects_packed = 0; - } - - // return the all_rects_packed status - return all_rects_packed; -} -#endif - -/* ------------------------------------------------------------------------------- -This software is available under 2 licenses -- choose whichever you prefer. ------------------------------------------------------------------------------- -ALTERNATIVE A - MIT License -Copyright (c) 2017 Sean Barrett -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. ------------------------------------------------------------------------------- -ALTERNATIVE B - Public Domain (www.unlicense.org) -This is free and unencumbered software released into the public domain. -Anyone is free to copy, modify, publish, use, compile, sell, or distribute this -software, either in source code form or as a compiled binary, for any purpose, -commercial or non-commercial, and by any means. -In jurisdictions that recognize copyright laws, the author or authors of this -software dedicate any and all copyright interest in the software to the public -domain. We make this dedication for the benefit of the public at large and to -the detriment of our heirs and successors. We intend this dedication to be an -overt act of relinquishment in perpetuity of all present and future rights to -this software under copyright law. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------- -*/ diff --git a/Extra2D/include/stb/stb_truetype.h b/Extra2D/include/stb/stb_truetype.h deleted file mode 100644 index 90a5c2e..0000000 --- a/Extra2D/include/stb/stb_truetype.h +++ /dev/null @@ -1,5079 +0,0 @@ -// stb_truetype.h - v1.26 - public domain -// authored from 2009-2021 by Sean Barrett / RAD Game Tools -// -// ======================================================================= -// -// NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES -// -// This library does no range checking of the offsets found in the file, -// meaning an attacker can use it to read arbitrary memory. -// -// ======================================================================= -// -// This library processes TrueType files: -// parse files -// extract glyph metrics -// extract glyph shapes -// render glyphs to one-channel bitmaps with antialiasing (box filter) -// render glyphs to one-channel SDF bitmaps (signed-distance field/function) -// -// Todo: -// non-MS cmaps -// crashproof on bad data -// hinting? (no longer patented) -// cleartype-style AA? -// optimize: use simple memory allocator for intermediates -// optimize: build edge-list directly from curves -// optimize: rasterize directly from curves? -// -// ADDITIONAL CONTRIBUTORS -// -// Mikko Mononen: compound shape support, more cmap formats -// Tor Andersson: kerning, subpixel rendering -// Dougall Johnson: OpenType / Type 2 font handling -// Daniel Ribeiro Maciel: basic GPOS-based kerning -// -// Misc other: -// Ryan Gordon -// Simon Glass -// github:IntellectualKitty -// Imanol Celaya -// Daniel Ribeiro Maciel -// -// Bug/warning reports/fixes: -// "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe -// Cass Everitt Martins Mozeiko github:aloucks -// stoiko (Haemimont Games) Cap Petschulat github:oyvindjam -// Brian Hook Omar Cornut github:vassvik -// Walter van Niftrik Ryan Griege -// David Gow Peter LaValle -// David Given Sergey Popov -// Ivan-Assen Ivanov Giumo X. Clanjor -// Anthony Pesch Higor Euripedes -// Johan Duparc Thomas Fields -// Hou Qiming Derek Vinyard -// Rob Loach Cort Stratton -// Kenney Phillis Jr. Brian Costabile -// Ken Voskuil (kaesve) Yakov Galka -// -// VERSION HISTORY -// -// 1.26 (2021-08-28) fix broken rasterizer -// 1.25 (2021-07-11) many fixes -// 1.24 (2020-02-05) fix warning -// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) -// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined -// 1.21 (2019-02-25) fix warning -// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() -// 1.19 (2018-02-11) GPOS kerning, STBTT_fmod -// 1.18 (2018-01-29) add missing function -// 1.17 (2017-07-23) make more arguments const; doc fix -// 1.16 (2017-07-12) SDF support -// 1.15 (2017-03-03) make more arguments const -// 1.14 (2017-01-16) num-fonts-in-TTC function -// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts -// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual -// 1.11 (2016-04-02) fix unused-variable warning -// 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef -// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly -// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges -// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; -// variant PackFontRanges to pack and render in separate phases; -// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); -// fixed an assert() bug in the new rasterizer -// replace assert() with STBTT_assert() in new rasterizer -// -// Full history can be found at the end of this file. -// -// LICENSE -// -// See end of file for license information. -// -// USAGE -// -// Include this file in whatever places need to refer to it. In ONE C/C++ -// file, write: -// #define STB_TRUETYPE_IMPLEMENTATION -// before the #include of this file. This expands out the actual -// implementation into that C/C++ file. -// -// To make the implementation private to the file that generates the implementation, -// #define STBTT_STATIC -// -// Simple 3D API (don't ship this, but it's fine for tools and quick start) -// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture -// stbtt_GetBakedQuad() -- compute quad to draw for a given char -// -// Improved 3D API (more shippable): -// #include "stb_rect_pack.h" -- optional, but you really want it -// stbtt_PackBegin() -// stbtt_PackSetOversampling() -- for improved quality on small fonts -// stbtt_PackFontRanges() -- pack and renders -// stbtt_PackEnd() -// stbtt_GetPackedQuad() -// -// "Load" a font file from a memory buffer (you have to keep the buffer loaded) -// stbtt_InitFont() -// stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections -// stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections -// -// Render a unicode codepoint to a bitmap -// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap -// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide -// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be -// -// Character advance/positioning -// stbtt_GetCodepointHMetrics() -// stbtt_GetFontVMetrics() -// stbtt_GetFontVMetricsOS2() -// stbtt_GetCodepointKernAdvance() -// -// Starting with version 1.06, the rasterizer was replaced with a new, -// faster and generally-more-precise rasterizer. The new rasterizer more -// accurately measures pixel coverage for anti-aliasing, except in the case -// where multiple shapes overlap, in which case it overestimates the AA pixel -// coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If -// this turns out to be a problem, you can re-enable the old rasterizer with -// #define STBTT_RASTERIZER_VERSION 1 -// which will incur about a 15% speed hit. -// -// ADDITIONAL DOCUMENTATION -// -// Immediately after this block comment are a series of sample programs. -// -// After the sample programs is the "header file" section. This section -// includes documentation for each API function. -// -// Some important concepts to understand to use this library: -// -// Codepoint -// Characters are defined by unicode codepoints, e.g. 65 is -// uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is -// the hiragana for "ma". -// -// Glyph -// A visual character shape (every codepoint is rendered as -// some glyph) -// -// Glyph index -// A font-specific integer ID representing a glyph -// -// Baseline -// Glyph shapes are defined relative to a baseline, which is the -// bottom of uppercase characters. Characters extend both above -// and below the baseline. -// -// Current Point -// As you draw text to the screen, you keep track of a "current point" -// which is the origin of each character. The current point's vertical -// position is the baseline. Even "baked fonts" use this model. -// -// Vertical Font Metrics -// The vertical qualities of the font, used to vertically position -// and space the characters. See docs for stbtt_GetFontVMetrics. -// -// Font Size in Pixels or Points -// The preferred interface for specifying font sizes in stb_truetype -// is to specify how tall the font's vertical extent should be in pixels. -// If that sounds good enough, skip the next paragraph. -// -// Most font APIs instead use "points", which are a common typographic -// measurement for describing font size, defined as 72 points per inch. -// stb_truetype provides a point API for compatibility. However, true -// "per inch" conventions don't make much sense on computer displays -// since different monitors have different number of pixels per -// inch. For example, Windows traditionally uses a convention that -// there are 96 pixels per inch, thus making 'inch' measurements have -// nothing to do with inches, and thus effectively defining a point to -// be 1.333 pixels. Additionally, the TrueType font data provides -// an explicit scale factor to scale a given font's glyphs to points, -// but the author has observed that this scale factor is often wrong -// for non-commercial fonts, thus making fonts scaled in points -// according to the TrueType spec incoherently sized in practice. -// -// DETAILED USAGE: -// -// Scale: -// Select how high you want the font to be, in points or pixels. -// Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute -// a scale factor SF that will be used by all other functions. -// -// Baseline: -// You need to select a y-coordinate that is the baseline of where -// your text will appear. Call GetFontBoundingBox to get the baseline-relative -// bounding box for all characters. SF*-y0 will be the distance in pixels -// that the worst-case character could extend above the baseline, so if -// you want the top edge of characters to appear at the top of the -// screen where y=0, then you would set the baseline to SF*-y0. -// -// Current point: -// Set the current point where the first character will appear. The -// first character could extend left of the current point; this is font -// dependent. You can either choose a current point that is the leftmost -// point and hope, or add some padding, or check the bounding box or -// left-side-bearing of the first character to be displayed and set -// the current point based on that. -// -// Displaying a character: -// Compute the bounding box of the character. It will contain signed values -// relative to . I.e. if it returns x0,y0,x1,y1, -// then the character should be displayed in the rectangle from -// to = 32 && *text < 128) { - stbtt_aligned_quad q; - stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9 - glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y0); - glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0); - glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1); - glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y1); - } - ++text; - } - glEnd(); -} -#endif -// -// -////////////////////////////////////////////////////////////////////////////// -// -// Complete program (this compiles): get a single bitmap, print as ASCII art -// -#if 0 -#include -#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation -#include "stb_truetype.h" - -char ttf_buffer[1<<25]; - -int main(int argc, char **argv) -{ - stbtt_fontinfo font; - unsigned char *bitmap; - int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); - - fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); - - stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); - bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); - - for (j=0; j < h; ++j) { - for (i=0; i < w; ++i) - putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); - putchar('\n'); - } - return 0; -} -#endif -// -// Output: -// -// .ii. -// @@@@@@. -// V@Mio@@o -// :i. V@V -// :oM@@M -// :@@@MM@M -// @@o o@M -// :@@. M@M -// @@@o@@@@ -// :M@@V:@@. -// -////////////////////////////////////////////////////////////////////////////// -// -// Complete program: print "Hello World!" banner, with bugs -// -#if 0 -char buffer[24<<20]; -unsigned char screen[20][79]; - -int main(int arg, char **argv) -{ - stbtt_fontinfo font; - int i,j,ascent,baseline,ch=0; - float scale, xpos=2; // leave a little padding in case the character extends left - char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness - - fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); - stbtt_InitFont(&font, buffer, 0); - - scale = stbtt_ScaleForPixelHeight(&font, 15); - stbtt_GetFontVMetrics(&font, &ascent,0,0); - baseline = (int) (ascent*scale); - - while (text[ch]) { - int advance,lsb,x0,y0,x1,y1; - float x_shift = xpos - (float) floor(xpos); - stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); - stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); - stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); - // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong - // because this API is really for baking character bitmaps into textures. if you want to render - // a sequence of characters, you really need to render each bitmap to a temp buffer, then - // "alpha blend" that into the working buffer - xpos += (advance * scale); - if (text[ch+1]) - xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); - ++ch; - } - - for (j=0; j < 20; ++j) { - for (i=0; i < 78; ++i) - putchar(" .:ioVM@"[screen[j][i]>>5]); - putchar('\n'); - } - - return 0; -} -#endif - - -////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////// -//// -//// INTEGRATION WITH YOUR CODEBASE -//// -//// The following sections allow you to supply alternate definitions -//// of C library functions used by stb_truetype, e.g. if you don't -//// link with the C runtime library. - -#ifdef STB_TRUETYPE_IMPLEMENTATION - // #define your own (u)stbtt_int8/16/32 before including to override this - #ifndef stbtt_uint8 - typedef unsigned char stbtt_uint8; - typedef signed char stbtt_int8; - typedef unsigned short stbtt_uint16; - typedef signed short stbtt_int16; - typedef unsigned int stbtt_uint32; - typedef signed int stbtt_int32; - #endif - - typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; - typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; - - // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h - #ifndef STBTT_ifloor - #include - #define STBTT_ifloor(x) ((int) floor(x)) - #define STBTT_iceil(x) ((int) ceil(x)) - #endif - - #ifndef STBTT_sqrt - #include - #define STBTT_sqrt(x) sqrt(x) - #define STBTT_pow(x,y) pow(x,y) - #endif - - #ifndef STBTT_fmod - #include - #define STBTT_fmod(x,y) fmod(x,y) - #endif - - #ifndef STBTT_cos - #include - #define STBTT_cos(x) cos(x) - #define STBTT_acos(x) acos(x) - #endif - - #ifndef STBTT_fabs - #include - #define STBTT_fabs(x) fabs(x) - #endif - - // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h - #ifndef STBTT_malloc - #include - #define STBTT_malloc(x,u) ((void)(u),malloc(x)) - #define STBTT_free(x,u) ((void)(u),free(x)) - #endif - - #ifndef STBTT_assert - #include - #define STBTT_assert(x) assert(x) - #endif - - #ifndef STBTT_strlen - #include - #define STBTT_strlen(x) strlen(x) - #endif - - #ifndef STBTT_memcpy - #include - #define STBTT_memcpy memcpy - #define STBTT_memset memset - #endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// -//// -//// INTERFACE -//// -//// - -#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ -#define __STB_INCLUDE_STB_TRUETYPE_H__ - -#ifdef STBTT_STATIC -#define STBTT_DEF static -#else -#define STBTT_DEF extern -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -// private structure -typedef struct -{ - unsigned char *data; - int cursor; - int size; -} stbtt__buf; - -////////////////////////////////////////////////////////////////////////////// -// -// TEXTURE BAKING API -// -// If you use this API, you only have to call two functions ever. -// - -typedef struct -{ - unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap - float xoff,yoff,xadvance; -} stbtt_bakedchar; - -STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) - float pixel_height, // height of font in pixels - unsigned char *pixels, int pw, int ph, // bitmap to be filled in - int first_char, int num_chars, // characters to bake - stbtt_bakedchar *chardata); // you allocate this, it's num_chars long -// if return is positive, the first unused row of the bitmap -// if return is negative, returns the negative of the number of characters that fit -// if return is 0, no characters fit and no rows were used -// This uses a very crappy packing. - -typedef struct -{ - float x0,y0,s0,t0; // top-left - float x1,y1,s1,t1; // bottom-right -} stbtt_aligned_quad; - -STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above - int char_index, // character to display - float *xpos, float *ypos, // pointers to current position in screen pixel space - stbtt_aligned_quad *q, // output: quad to draw - int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier -// Call GetBakedQuad with char_index = 'character - first_char', and it -// creates the quad you need to draw and advances the current position. -// -// The coordinate system used assumes y increases downwards. -// -// Characters will extend both above and below the current position; -// see discussion of "BASELINE" above. -// -// It's inefficient; you might want to c&p it and optimize it. - -STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); -// Query the font vertical metrics without having to create a font first. - - -////////////////////////////////////////////////////////////////////////////// -// -// NEW TEXTURE BAKING API -// -// This provides options for packing multiple fonts into one atlas, not -// perfectly but better than nothing. - -typedef struct -{ - unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap - float xoff,yoff,xadvance; - float xoff2,yoff2; -} stbtt_packedchar; - -typedef struct stbtt_pack_context stbtt_pack_context; -typedef struct stbtt_fontinfo stbtt_fontinfo; -#ifndef STB_RECT_PACK_VERSION -typedef struct stbrp_rect stbrp_rect; -#endif - -STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); -// Initializes a packing context stored in the passed-in stbtt_pack_context. -// Future calls using this context will pack characters into the bitmap passed -// in here: a 1-channel bitmap that is width * height. stride_in_bytes is -// the distance from one row to the next (or 0 to mean they are packed tightly -// together). "padding" is the amount of padding to leave between each -// character (normally you want '1' for bitmaps you'll use as textures with -// bilinear filtering). -// -// Returns 0 on failure, 1 on success. - -STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); -// Cleans up the packing context and frees all memory. - -#define STBTT_POINT_SIZE(x) (-(x)) - -STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, - int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); -// Creates character bitmaps from the font_index'th font found in fontdata (use -// font_index=0 if you don't know what that is). It creates num_chars_in_range -// bitmaps for characters with unicode values starting at first_unicode_char_in_range -// and increasing. Data for how to render them is stored in chardata_for_range; -// pass these to stbtt_GetPackedQuad to get back renderable quads. -// -// font_size is the full height of the character from ascender to descender, -// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed -// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() -// and pass that result as 'font_size': -// ..., 20 , ... // font max minus min y is 20 pixels tall -// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall - -typedef struct -{ - float font_size; - int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint - int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints - int num_chars; - stbtt_packedchar *chardata_for_range; // output - unsigned char h_oversample, v_oversample; // don't set these, they're used internally -} stbtt_pack_range; - -STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); -// Creates character bitmaps from multiple ranges of characters stored in -// ranges. This will usually create a better-packed bitmap than multiple -// calls to stbtt_PackFontRange. Note that you can call this multiple -// times within a single PackBegin/PackEnd. - -STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); -// Oversampling a font increases the quality by allowing higher-quality subpixel -// positioning, and is especially valuable at smaller text sizes. -// -// This function sets the amount of oversampling for all following calls to -// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given -// pack context. The default (no oversampling) is achieved by h_oversample=1 -// and v_oversample=1. The total number of pixels required is -// h_oversample*v_oversample larger than the default; for example, 2x2 -// oversampling requires 4x the storage of 1x1. For best results, render -// oversampled textures with bilinear filtering. Look at the readme in -// stb/tests/oversample for information about oversampled fonts -// -// To use with PackFontRangesGather etc., you must set it before calls -// call to PackFontRangesGatherRects. - -STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); -// If skip != 0, this tells stb_truetype to skip any codepoints for which -// there is no corresponding glyph. If skip=0, which is the default, then -// codepoints without a glyph recived the font's "missing character" glyph, -// typically an empty box by convention. - -STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above - int char_index, // character to display - float *xpos, float *ypos, // pointers to current position in screen pixel space - stbtt_aligned_quad *q, // output: quad to draw - int align_to_integer); - -STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); -STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); -STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); -// Calling these functions in sequence is roughly equivalent to calling -// stbtt_PackFontRanges(). If you more control over the packing of multiple -// fonts, or if you want to pack custom data into a font texture, take a look -// at the source to of stbtt_PackFontRanges() and create a custom version -// using these functions, e.g. call GatherRects multiple times, -// building up a single array of rects, then call PackRects once, -// then call RenderIntoRects repeatedly. This may result in a -// better packing than calling PackFontRanges multiple times -// (or it may not). - -// this is an opaque structure that you shouldn't mess with which holds -// all the context needed from PackBegin to PackEnd. -struct stbtt_pack_context { - void *user_allocator_context; - void *pack_info; - int width; - int height; - int stride_in_bytes; - int padding; - int skip_missing; - unsigned int h_oversample, v_oversample; - unsigned char *pixels; - void *nodes; -}; - -////////////////////////////////////////////////////////////////////////////// -// -// FONT LOADING -// -// - -STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); -// This function will determine the number of fonts in a font file. TrueType -// collection (.ttc) files may contain multiple fonts, while TrueType font -// (.ttf) files only contain one font. The number of fonts can be used for -// indexing with the previous function where the index is between zero and one -// less than the total fonts. If an error occurs, -1 is returned. - -STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); -// Each .ttf/.ttc file may have more than one font. Each font has a sequential -// index number starting from 0. Call this function to get the font offset for -// a given index; it returns -1 if the index is out of range. A regular .ttf -// file will only define one font and it always be at offset 0, so it will -// return '0' for index 0, and -1 for all other indices. - -// The following structure is defined publicly so you can declare one on -// the stack or as a global or etc, but you should treat it as opaque. -struct stbtt_fontinfo -{ - void * userdata; - unsigned char * data; // pointer to .ttf file - int fontstart; // offset of start of font - - int numGlyphs; // number of glyphs, needed for range checking - - int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf - int index_map; // a cmap mapping for our chosen character encoding - int indexToLocFormat; // format needed to map from glyph index to glyph - - stbtt__buf cff; // cff font data - stbtt__buf charstrings; // the charstring index - stbtt__buf gsubrs; // global charstring subroutines index - stbtt__buf subrs; // private charstring subroutines index - stbtt__buf fontdicts; // array of font dicts - stbtt__buf fdselect; // map from glyph to fontdict -}; - -STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); -// Given an offset into the file that defines a font, this function builds -// the necessary cached info for the rest of the system. You must allocate -// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't -// need to do anything special to free it, because the contents are pure -// value data with no additional data structures. Returns 0 on failure. - - -////////////////////////////////////////////////////////////////////////////// -// -// CHARACTER TO GLYPH-INDEX CONVERSIOn - -STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); -// If you're going to perform multiple operations on the same character -// and you want a speed-up, call this function with the character you're -// going to process, then use glyph-based functions instead of the -// codepoint-based functions. -// Returns 0 if the character codepoint is not defined in the font. - - -////////////////////////////////////////////////////////////////////////////// -// -// CHARACTER PROPERTIES -// - -STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); -// computes a scale factor to produce a font whose "height" is 'pixels' tall. -// Height is measured as the distance from the highest ascender to the lowest -// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics -// and computing: -// scale = pixels / (ascent - descent) -// so if you prefer to measure height by the ascent only, use a similar calculation. - -STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels); -// computes a scale factor to produce a font whose EM size is mapped to -// 'pixels' tall. This is probably what traditional APIs compute, but -// I'm not positive. - -STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); -// ascent is the coordinate above the baseline the font extends; descent -// is the coordinate below the baseline the font extends (i.e. it is typically negative) -// lineGap is the spacing between one row's descent and the next row's ascent... -// so you should advance the vertical position by "*ascent - *descent + *lineGap" -// these are expressed in unscaled coordinates, so you must multiply by -// the scale factor for a given size - -STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); -// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 -// table (specific to MS/Windows TTF files). -// -// Returns 1 on success (table present), 0 on failure. - -STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); -// the bounding box around all possible characters - -STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); -// leftSideBearing is the offset from the current horizontal position to the left edge of the character -// advanceWidth is the offset from the current horizontal position to the next horizontal position -// these are expressed in unscaled coordinates - -STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); -// an additional amount to add to the 'advance' value between ch1 and ch2 - -STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); -// Gets the bounding box of the visible part of the glyph, in unscaled coordinates - -STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); -STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); -STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); -// as above, but takes one or more glyph indices for greater efficiency - -typedef struct stbtt_kerningentry -{ - int glyph1; // use stbtt_FindGlyphIndex - int glyph2; - int advance; -} stbtt_kerningentry; - -STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); -STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); -// Retrieves a complete list of all of the kerning pairs provided by the font -// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. -// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) - -////////////////////////////////////////////////////////////////////////////// -// -// GLYPH SHAPES (you probably don't need these, but they have to go before -// the bitmaps for C declaration-order reasons) -// - -#ifndef STBTT_vmove // you can predefine these to use different values (but why?) - enum { - STBTT_vmove=1, - STBTT_vline, - STBTT_vcurve, - STBTT_vcubic - }; -#endif - -#ifndef stbtt_vertex // you can predefine this to use different values - // (we share this with other code at RAD) - #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file - typedef struct - { - stbtt_vertex_type x,y,cx,cy,cx1,cy1; - unsigned char type,padding; - } stbtt_vertex; -#endif - -STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); -// returns non-zero if nothing is drawn for this glyph - -STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); -STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); -// returns # of vertices and fills *vertices with the pointer to them -// these are expressed in "unscaled" coordinates -// -// The shape is a series of contours. Each one starts with -// a STBTT_moveto, then consists of a series of mixed -// STBTT_lineto and STBTT_curveto segments. A lineto -// draws a line from previous endpoint to its x,y; a curveto -// draws a quadratic bezier from previous endpoint to -// its x,y, using cx,cy as the bezier control point. - -STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); -// frees the data allocated above - -STBTT_DEF unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl); -STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); -STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); -// fills svg with the character's SVG data. -// returns data size or 0 if SVG not found. - -////////////////////////////////////////////////////////////////////////////// -// -// BITMAP RENDERING -// - -STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); -// frees the bitmap allocated below - -STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); -// allocates a large-enough single-channel 8bpp bitmap and renders the -// specified character/glyph at the specified scale into it, with -// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). -// *width & *height are filled out with the width & height of the bitmap, -// which is stored left-to-right, top-to-bottom. -// -// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap - -STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); -// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel -// shift for the character - -STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); -// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap -// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap -// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the -// width and height and positioning info for it first. - -STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint); -// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel -// shift for the character - -STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint); -// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering -// is performed (see stbtt_PackSetOversampling) - -STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); -// get the bbox of the bitmap centered around the glyph origin; so the -// bitmap width is ix1-ix0, height is iy1-iy0, and location to place -// the bitmap top left is (leftSideBearing*scale,iy0). -// (Note that the bitmap uses y-increases-down, but the shape uses -// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) - -STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); -// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel -// shift for the character - -// the following functions are equivalent to the above functions, but operate -// on glyph indices instead of Unicode codepoints (for efficiency) -STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); -STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); -STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); -STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); -STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); -STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); -STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); - - -// @TODO: don't expose this structure -typedef struct -{ - int w,h,stride; - unsigned char *pixels; -} stbtt__bitmap; - -// rasterize a shape with quadratic beziers into a bitmap -STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into - float flatness_in_pixels, // allowable error of curve in pixels - stbtt_vertex *vertices, // array of vertices defining shape - int num_verts, // number of vertices in above array - float scale_x, float scale_y, // scale applied to input vertices - float shift_x, float shift_y, // translation applied to input vertices - int x_off, int y_off, // another translation applied to input - int invert, // if non-zero, vertically flip shape - void *userdata); // context for to STBTT_MALLOC - -////////////////////////////////////////////////////////////////////////////// -// -// Signed Distance Function (or Field) rendering - -STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); -// frees the SDF bitmap allocated below - -STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); -STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); -// These functions compute a discretized SDF field for a single character, suitable for storing -// in a single-channel texture, sampling with bilinear filtering, and testing against -// larger than some threshold to produce scalable fonts. -// info -- the font -// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap -// glyph/codepoint -- the character to generate the SDF for -// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), -// which allows effects like bit outlines -// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) -// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) -// if positive, > onedge_value is inside; if negative, < onedge_value is inside -// width,height -- output height & width of the SDF bitmap (including padding) -// xoff,yoff -- output origin of the character -// return value -- a 2D array of bytes 0..255, width*height in size -// -// pixel_dist_scale & onedge_value are a scale & bias that allows you to make -// optimal use of the limited 0..255 for your application, trading off precision -// and special effects. SDF values outside the range 0..255 are clamped to 0..255. -// -// Example: -// scale = stbtt_ScaleForPixelHeight(22) -// padding = 5 -// onedge_value = 180 -// pixel_dist_scale = 180/5.0 = 36.0 -// -// This will create an SDF bitmap in which the character is about 22 pixels -// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled -// shape, sample the SDF at each pixel and fill the pixel if the SDF value -// is greater than or equal to 180/255. (You'll actually want to antialias, -// which is beyond the scope of this example.) Additionally, you can compute -// offset outlines (e.g. to stroke the character border inside & outside, -// or only outside). For example, to fill outside the character up to 3 SDF -// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above -// choice of variables maps a range from 5 pixels outside the shape to -// 2 pixels inside the shape to 0..255; this is intended primarily for apply -// outside effects only (the interior range is needed to allow proper -// antialiasing of the font at *smaller* sizes) -// -// The function computes the SDF analytically at each SDF pixel, not by e.g. -// building a higher-res bitmap and approximating it. In theory the quality -// should be as high as possible for an SDF of this size & representation, but -// unclear if this is true in practice (perhaps building a higher-res bitmap -// and computing from that can allow drop-out prevention). -// -// The algorithm has not been optimized at all, so expect it to be slow -// if computing lots of characters or very large sizes. - - - -////////////////////////////////////////////////////////////////////////////// -// -// Finding the right font... -// -// You should really just solve this offline, keep your own tables -// of what font is what, and don't try to get it out of the .ttf file. -// That's because getting it out of the .ttf file is really hard, because -// the names in the file can appear in many possible encodings, in many -// possible languages, and e.g. if you need a case-insensitive comparison, -// the details of that depend on the encoding & language in a complex way -// (actually underspecified in truetype, but also gigantic). -// -// But you can use the provided functions in two possible ways: -// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on -// unicode-encoded names to try to find the font you want; -// you can run this before calling stbtt_InitFont() -// -// stbtt_GetFontNameString() lets you get any of the various strings -// from the file yourself and do your own comparisons on them. -// You have to have called stbtt_InitFont() first. - - -STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); -// returns the offset (not index) of the font that matches, or -1 if none -// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". -// if you use any other flag, use a font name like "Arial"; this checks -// the 'macStyle' header field; i don't know if fonts set this consistently -#define STBTT_MACSTYLE_DONTCARE 0 -#define STBTT_MACSTYLE_BOLD 1 -#define STBTT_MACSTYLE_ITALIC 2 -#define STBTT_MACSTYLE_UNDERSCORE 4 -#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 - -STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); -// returns 1/0 whether the first string interpreted as utf8 is identical to -// the second string interpreted as big-endian utf16... useful for strings from next func - -STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); -// returns the string (which may be big-endian double byte, e.g. for unicode) -// and puts the length in bytes in *length. -// -// some of the values for the IDs are below; for more see the truetype spec: -// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html -// http://www.microsoft.com/typography/otspec/name.htm - -enum { // platformID - STBTT_PLATFORM_ID_UNICODE =0, - STBTT_PLATFORM_ID_MAC =1, - STBTT_PLATFORM_ID_ISO =2, - STBTT_PLATFORM_ID_MICROSOFT =3 -}; - -enum { // encodingID for STBTT_PLATFORM_ID_UNICODE - STBTT_UNICODE_EID_UNICODE_1_0 =0, - STBTT_UNICODE_EID_UNICODE_1_1 =1, - STBTT_UNICODE_EID_ISO_10646 =2, - STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, - STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 -}; - -enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT - STBTT_MS_EID_SYMBOL =0, - STBTT_MS_EID_UNICODE_BMP =1, - STBTT_MS_EID_SHIFTJIS =2, - STBTT_MS_EID_UNICODE_FULL =10 -}; - -enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes - STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, - STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, - STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, - STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 -}; - -enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... - // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs - STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, - STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, - STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, - STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, - STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, - STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D -}; - -enum { // languageID for STBTT_PLATFORM_ID_MAC - STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, - STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, - STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, - STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , - STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , - STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, - STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 -}; - -#ifdef __cplusplus -} -#endif - -#endif // __STB_INCLUDE_STB_TRUETYPE_H__ - -/////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// -//// -//// IMPLEMENTATION -//// -//// - -#ifdef STB_TRUETYPE_IMPLEMENTATION - -#ifndef STBTT_MAX_OVERSAMPLE -#define STBTT_MAX_OVERSAMPLE 8 -#endif - -#if STBTT_MAX_OVERSAMPLE > 255 -#error "STBTT_MAX_OVERSAMPLE cannot be > 255" -#endif - -typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]; - -#ifndef STBTT_RASTERIZER_VERSION -#define STBTT_RASTERIZER_VERSION 2 -#endif - -#ifdef _MSC_VER -#define STBTT__NOTUSED(v) (void)(v) -#else -#define STBTT__NOTUSED(v) (void)sizeof(v) -#endif - -////////////////////////////////////////////////////////////////////////// -// -// stbtt__buf helpers to parse data from file -// - -static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) -{ - if (b->cursor >= b->size) - return 0; - return b->data[b->cursor++]; -} - -static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) -{ - if (b->cursor >= b->size) - return 0; - return b->data[b->cursor]; -} - -static void stbtt__buf_seek(stbtt__buf *b, int o) -{ - STBTT_assert(!(o > b->size || o < 0)); - b->cursor = (o > b->size || o < 0) ? b->size : o; -} - -static void stbtt__buf_skip(stbtt__buf *b, int o) -{ - stbtt__buf_seek(b, b->cursor + o); -} - -static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) -{ - stbtt_uint32 v = 0; - int i; - STBTT_assert(n >= 1 && n <= 4); - for (i = 0; i < n; i++) - v = (v << 8) | stbtt__buf_get8(b); - return v; -} - -static stbtt__buf stbtt__new_buf(const void *p, size_t size) -{ - stbtt__buf r; - STBTT_assert(size < 0x40000000); - r.data = (stbtt_uint8*) p; - r.size = (int) size; - r.cursor = 0; - return r; -} - -#define stbtt__buf_get16(b) stbtt__buf_get((b), 2) -#define stbtt__buf_get32(b) stbtt__buf_get((b), 4) - -static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s) -{ - stbtt__buf r = stbtt__new_buf(NULL, 0); - if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r; - r.data = b->data + o; - r.size = s; - return r; -} - -static stbtt__buf stbtt__cff_get_index(stbtt__buf *b) -{ - int count, start, offsize; - start = b->cursor; - count = stbtt__buf_get16(b); - if (count) { - offsize = stbtt__buf_get8(b); - STBTT_assert(offsize >= 1 && offsize <= 4); - stbtt__buf_skip(b, offsize * count); - stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1); - } - return stbtt__buf_range(b, start, b->cursor - start); -} - -static stbtt_uint32 stbtt__cff_int(stbtt__buf *b) -{ - int b0 = stbtt__buf_get8(b); - if (b0 >= 32 && b0 <= 246) return b0 - 139; - else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108; - else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108; - else if (b0 == 28) return stbtt__buf_get16(b); - else if (b0 == 29) return stbtt__buf_get32(b); - STBTT_assert(0); - return 0; -} - -static void stbtt__cff_skip_operand(stbtt__buf *b) { - int v, b0 = stbtt__buf_peek8(b); - STBTT_assert(b0 >= 28); - if (b0 == 30) { - stbtt__buf_skip(b, 1); - while (b->cursor < b->size) { - v = stbtt__buf_get8(b); - if ((v & 0xF) == 0xF || (v >> 4) == 0xF) - break; - } - } else { - stbtt__cff_int(b); - } -} - -static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key) -{ - stbtt__buf_seek(b, 0); - while (b->cursor < b->size) { - int start = b->cursor, end, op; - while (stbtt__buf_peek8(b) >= 28) - stbtt__cff_skip_operand(b); - end = b->cursor; - op = stbtt__buf_get8(b); - if (op == 12) op = stbtt__buf_get8(b) | 0x100; - if (op == key) return stbtt__buf_range(b, start, end-start); - } - return stbtt__buf_range(b, 0, 0); -} - -static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out) -{ - int i; - stbtt__buf operands = stbtt__dict_get(b, key); - for (i = 0; i < outcount && operands.cursor < operands.size; i++) - out[i] = stbtt__cff_int(&operands); -} - -static int stbtt__cff_index_count(stbtt__buf *b) -{ - stbtt__buf_seek(b, 0); - return stbtt__buf_get16(b); -} - -static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) -{ - int count, offsize, start, end; - stbtt__buf_seek(&b, 0); - count = stbtt__buf_get16(&b); - offsize = stbtt__buf_get8(&b); - STBTT_assert(i >= 0 && i < count); - STBTT_assert(offsize >= 1 && offsize <= 4); - stbtt__buf_skip(&b, i*offsize); - start = stbtt__buf_get(&b, offsize); - end = stbtt__buf_get(&b, offsize); - return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); -} - -////////////////////////////////////////////////////////////////////////// -// -// accessors to parse data from file -// - -// on platforms that don't allow misaligned reads, if we want to allow -// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE - -#define ttBYTE(p) (* (stbtt_uint8 *) (p)) -#define ttCHAR(p) (* (stbtt_int8 *) (p)) -#define ttFixed(p) ttLONG(p) - -static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } -static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } -static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } -static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } - -#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) -#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) - -static int stbtt__isfont(stbtt_uint8 *font) -{ - // check the version number - if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 - if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! - if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF - if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 - if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts - return 0; -} - -// @OPTIMIZE: binary search -static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) -{ - stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); - stbtt_uint32 tabledir = fontstart + 12; - stbtt_int32 i; - for (i=0; i < num_tables; ++i) { - stbtt_uint32 loc = tabledir + 16*i; - if (stbtt_tag(data+loc+0, tag)) - return ttULONG(data+loc+8); - } - return 0; -} - -static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) -{ - // if it's just a font, there's only one valid index - if (stbtt__isfont(font_collection)) - return index == 0 ? 0 : -1; - - // check if it's a TTC - if (stbtt_tag(font_collection, "ttcf")) { - // version 1? - if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { - stbtt_int32 n = ttLONG(font_collection+8); - if (index >= n) - return -1; - return ttULONG(font_collection+12+index*4); - } - } - return -1; -} - -static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) -{ - // if it's just a font, there's only one valid font - if (stbtt__isfont(font_collection)) - return 1; - - // check if it's a TTC - if (stbtt_tag(font_collection, "ttcf")) { - // version 1? - if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { - return ttLONG(font_collection+8); - } - } - return 0; -} - -static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) -{ - stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 }; - stbtt__buf pdict; - stbtt__dict_get_ints(&fontdict, 18, 2, private_loc); - if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0); - pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]); - stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff); - if (!subrsoff) return stbtt__new_buf(NULL, 0); - stbtt__buf_seek(&cff, private_loc[1]+subrsoff); - return stbtt__cff_get_index(&cff); -} - -// since most people won't use this, find this table the first time it's needed -static int stbtt__get_svg(stbtt_fontinfo *info) -{ - stbtt_uint32 t; - if (info->svg < 0) { - t = stbtt__find_table(info->data, info->fontstart, "SVG "); - if (t) { - stbtt_uint32 offset = ttULONG(info->data + t + 2); - info->svg = t + offset; - } else { - info->svg = 0; - } - } - return info->svg; -} - -static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart) -{ - stbtt_uint32 cmap, t; - stbtt_int32 i,numTables; - - info->data = data; - info->fontstart = fontstart; - info->cff = stbtt__new_buf(NULL, 0); - - cmap = stbtt__find_table(data, fontstart, "cmap"); // required - info->loca = stbtt__find_table(data, fontstart, "loca"); // required - info->head = stbtt__find_table(data, fontstart, "head"); // required - info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required - info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required - info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required - info->kern = stbtt__find_table(data, fontstart, "kern"); // not required - info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required - - if (!cmap || !info->head || !info->hhea || !info->hmtx) - return 0; - if (info->glyf) { - // required for truetype - if (!info->loca) return 0; - } else { - // initialization for CFF / Type2 fonts (OTF) - stbtt__buf b, topdict, topdictidx; - stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; - stbtt_uint32 cff; - - cff = stbtt__find_table(data, fontstart, "CFF "); - if (!cff) return 0; - - info->fontdicts = stbtt__new_buf(NULL, 0); - info->fdselect = stbtt__new_buf(NULL, 0); - - // @TODO this should use size from table (not 512MB) - info->cff = stbtt__new_buf(data+cff, 512*1024*1024); - b = info->cff; - - // read the header - stbtt__buf_skip(&b, 2); - stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize - - // @TODO the name INDEX could list multiple fonts, - // but we just use the first one. - stbtt__cff_get_index(&b); // name INDEX - topdictidx = stbtt__cff_get_index(&b); - topdict = stbtt__cff_index_get(topdictidx, 0); - stbtt__cff_get_index(&b); // string INDEX - info->gsubrs = stbtt__cff_get_index(&b); - - stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); - stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype); - stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff); - stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); - info->subrs = stbtt__get_subrs(b, topdict); - - // we only support Type 2 charstrings - if (cstype != 2) return 0; - if (charstrings == 0) return 0; - - if (fdarrayoff) { - // looks like a CID font - if (!fdselectoff) return 0; - stbtt__buf_seek(&b, fdarrayoff); - info->fontdicts = stbtt__cff_get_index(&b); - info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff); - } - - stbtt__buf_seek(&b, charstrings); - info->charstrings = stbtt__cff_get_index(&b); - } - - t = stbtt__find_table(data, fontstart, "maxp"); - if (t) - info->numGlyphs = ttUSHORT(data+t+4); - else - info->numGlyphs = 0xffff; - - info->svg = -1; - - // find a cmap encoding table we understand *now* to avoid searching - // later. (todo: could make this installable) - // the same regardless of glyph. - numTables = ttUSHORT(data + cmap + 2); - info->index_map = 0; - for (i=0; i < numTables; ++i) { - stbtt_uint32 encoding_record = cmap + 4 + 8 * i; - // find an encoding we understand: - switch(ttUSHORT(data+encoding_record)) { - case STBTT_PLATFORM_ID_MICROSOFT: - switch (ttUSHORT(data+encoding_record+2)) { - case STBTT_MS_EID_UNICODE_BMP: - case STBTT_MS_EID_UNICODE_FULL: - // MS/Unicode - info->index_map = cmap + ttULONG(data+encoding_record+4); - break; - } - break; - case STBTT_PLATFORM_ID_UNICODE: - // Mac/iOS has these - // all the encodingIDs are unicode, so we don't bother to check it - info->index_map = cmap + ttULONG(data+encoding_record+4); - break; - } - } - if (info->index_map == 0) - return 0; - - info->indexToLocFormat = ttUSHORT(data+info->head + 50); - return 1; -} - -STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) -{ - stbtt_uint8 *data = info->data; - stbtt_uint32 index_map = info->index_map; - - stbtt_uint16 format = ttUSHORT(data + index_map + 0); - if (format == 0) { // apple byte encoding - stbtt_int32 bytes = ttUSHORT(data + index_map + 2); - if (unicode_codepoint < bytes-6) - return ttBYTE(data + index_map + 6 + unicode_codepoint); - return 0; - } else if (format == 6) { - stbtt_uint32 first = ttUSHORT(data + index_map + 6); - stbtt_uint32 count = ttUSHORT(data + index_map + 8); - if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) - return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); - return 0; - } else if (format == 2) { - STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean - return 0; - } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges - stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; - stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; - stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); - stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; - - // do a binary search of the segments - stbtt_uint32 endCount = index_map + 14; - stbtt_uint32 search = endCount; - - if (unicode_codepoint > 0xffff) - return 0; - - // they lie from endCount .. endCount + segCount - // but searchRange is the nearest power of two, so... - if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) - search += rangeShift*2; - - // now decrement to bias correctly to find smallest - search -= 2; - while (entrySelector) { - stbtt_uint16 end; - searchRange >>= 1; - end = ttUSHORT(data + search + searchRange*2); - if (unicode_codepoint > end) - search += searchRange*2; - --entrySelector; - } - search += 2; - - { - stbtt_uint16 offset, start, last; - stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); - - start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); - last = ttUSHORT(data + endCount + 2*item); - if (unicode_codepoint < start || unicode_codepoint > last) - return 0; - - offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); - if (offset == 0) - return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); - - return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); - } - } else if (format == 12 || format == 13) { - stbtt_uint32 ngroups = ttULONG(data+index_map+12); - stbtt_int32 low,high; - low = 0; high = (stbtt_int32)ngroups; - // Binary search the right group. - while (low < high) { - stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high - stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); - stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); - if ((stbtt_uint32) unicode_codepoint < start_char) - high = mid; - else if ((stbtt_uint32) unicode_codepoint > end_char) - low = mid+1; - else { - stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); - if (format == 12) - return start_glyph + unicode_codepoint-start_char; - else // format == 13 - return start_glyph; - } - } - return 0; // not found - } - // @TODO - STBTT_assert(0); - return 0; -} - -STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) -{ - return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); -} - -static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy) -{ - v->type = type; - v->x = (stbtt_int16) x; - v->y = (stbtt_int16) y; - v->cx = (stbtt_int16) cx; - v->cy = (stbtt_int16) cy; -} - -static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) -{ - int g1,g2; - - STBTT_assert(!info->cff.size); - - if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range - if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format - - if (info->indexToLocFormat == 0) { - g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; - g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; - } else { - g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); - g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); - } - - return g1==g2 ? -1 : g1; // if length is 0, return -1 -} - -static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); - -STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) -{ - if (info->cff.size) { - stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1); - } else { - int g = stbtt__GetGlyfOffset(info, glyph_index); - if (g < 0) return 0; - - if (x0) *x0 = ttSHORT(info->data + g + 2); - if (y0) *y0 = ttSHORT(info->data + g + 4); - if (x1) *x1 = ttSHORT(info->data + g + 6); - if (y1) *y1 = ttSHORT(info->data + g + 8); - } - return 1; -} - -STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) -{ - return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); -} - -STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) -{ - stbtt_int16 numberOfContours; - int g; - if (info->cff.size) - return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0; - g = stbtt__GetGlyfOffset(info, glyph_index); - if (g < 0) return 1; - numberOfContours = ttSHORT(info->data + g); - return numberOfContours == 0; -} - -static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, - stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) -{ - if (start_off) { - if (was_off) - stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); - stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); - } else { - if (was_off) - stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); - else - stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); - } - return num_vertices; -} - -static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) -{ - stbtt_int16 numberOfContours; - stbtt_uint8 *endPtsOfContours; - stbtt_uint8 *data = info->data; - stbtt_vertex *vertices=0; - int num_vertices=0; - int g = stbtt__GetGlyfOffset(info, glyph_index); - - *pvertices = NULL; - - if (g < 0) return 0; - - numberOfContours = ttSHORT(data + g); - - if (numberOfContours > 0) { - stbtt_uint8 flags=0,flagcount; - stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; - stbtt_int32 x,y,cx,cy,sx,sy, scx,scy; - stbtt_uint8 *points; - endPtsOfContours = (data + g + 10); - ins = ttUSHORT(data + g + 10 + numberOfContours * 2); - points = data + g + 10 + numberOfContours * 2 + 2 + ins; - - n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); - - m = n + 2*numberOfContours; // a loose bound on how many vertices we might need - vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); - if (vertices == 0) - return 0; - - next_move = 0; - flagcount=0; - - // in first pass, we load uninterpreted data into the allocated array - // above, shifted to the end of the array so we won't overwrite it when - // we create our final data starting from the front - - off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated - - // first load flags - - for (i=0; i < n; ++i) { - if (flagcount == 0) { - flags = *points++; - if (flags & 8) - flagcount = *points++; - } else - --flagcount; - vertices[off+i].type = flags; - } - - // now load x coordinates - x=0; - for (i=0; i < n; ++i) { - flags = vertices[off+i].type; - if (flags & 2) { - stbtt_int16 dx = *points++; - x += (flags & 16) ? dx : -dx; // ??? - } else { - if (!(flags & 16)) { - x = x + (stbtt_int16) (points[0]*256 + points[1]); - points += 2; - } - } - vertices[off+i].x = (stbtt_int16) x; - } - - // now load y coordinates - y=0; - for (i=0; i < n; ++i) { - flags = vertices[off+i].type; - if (flags & 4) { - stbtt_int16 dy = *points++; - y += (flags & 32) ? dy : -dy; // ??? - } else { - if (!(flags & 32)) { - y = y + (stbtt_int16) (points[0]*256 + points[1]); - points += 2; - } - } - vertices[off+i].y = (stbtt_int16) y; - } - - // now convert them to our format - num_vertices=0; - sx = sy = cx = cy = scx = scy = 0; - for (i=0; i < n; ++i) { - flags = vertices[off+i].type; - x = (stbtt_int16) vertices[off+i].x; - y = (stbtt_int16) vertices[off+i].y; - - if (next_move == i) { - if (i != 0) - num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); - - // now start the new one - start_off = !(flags & 1); - if (start_off) { - // if we start off with an off-curve point, then when we need to find a point on the curve - // where we can start, and we need to save some state for when we wraparound. - scx = x; - scy = y; - if (!(vertices[off+i+1].type & 1)) { - // next point is also a curve point, so interpolate an on-point curve - sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; - sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; - } else { - // otherwise just use the next point as our start point - sx = (stbtt_int32) vertices[off+i+1].x; - sy = (stbtt_int32) vertices[off+i+1].y; - ++i; // we're using point i+1 as the starting point, so skip it - } - } else { - sx = x; - sy = y; - } - stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); - was_off = 0; - next_move = 1 + ttUSHORT(endPtsOfContours+j*2); - ++j; - } else { - if (!(flags & 1)) { // if it's a curve - if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint - stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); - cx = x; - cy = y; - was_off = 1; - } else { - if (was_off) - stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); - else - stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); - was_off = 0; - } - } - } - num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); - } else if (numberOfContours < 0) { - // Compound shapes. - int more = 1; - stbtt_uint8 *comp = data + g + 10; - num_vertices = 0; - vertices = 0; - while (more) { - stbtt_uint16 flags, gidx; - int comp_num_verts = 0, i; - stbtt_vertex *comp_verts = 0, *tmp = 0; - float mtx[6] = {1,0,0,1,0,0}, m, n; - - flags = ttSHORT(comp); comp+=2; - gidx = ttSHORT(comp); comp+=2; - - if (flags & 2) { // XY values - if (flags & 1) { // shorts - mtx[4] = ttSHORT(comp); comp+=2; - mtx[5] = ttSHORT(comp); comp+=2; - } else { - mtx[4] = ttCHAR(comp); comp+=1; - mtx[5] = ttCHAR(comp); comp+=1; - } - } - else { - // @TODO handle matching point - STBTT_assert(0); - } - if (flags & (1<<3)) { // WE_HAVE_A_SCALE - mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; - mtx[1] = mtx[2] = 0; - } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE - mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; - mtx[1] = mtx[2] = 0; - mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; - } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO - mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; - mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; - mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; - mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; - } - - // Find transformation scales. - m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); - n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); - - // Get indexed glyph. - comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); - if (comp_num_verts > 0) { - // Transform vertices. - for (i = 0; i < comp_num_verts; ++i) { - stbtt_vertex* v = &comp_verts[i]; - stbtt_vertex_type x,y; - x=v->x; y=v->y; - v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); - v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); - x=v->cx; y=v->cy; - v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); - v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); - } - // Append vertices. - tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); - if (!tmp) { - if (vertices) STBTT_free(vertices, info->userdata); - if (comp_verts) STBTT_free(comp_verts, info->userdata); - return 0; - } - if (num_vertices > 0 && vertices) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); - STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); - if (vertices) STBTT_free(vertices, info->userdata); - vertices = tmp; - STBTT_free(comp_verts, info->userdata); - num_vertices += comp_num_verts; - } - // More components ? - more = flags & (1<<5); - } - } else { - // numberOfCounters == 0, do nothing - } - - *pvertices = vertices; - return num_vertices; -} - -typedef struct -{ - int bounds; - int started; - float first_x, first_y; - float x, y; - stbtt_int32 min_x, max_x, min_y, max_y; - - stbtt_vertex *pvertices; - int num_vertices; -} stbtt__csctx; - -#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0} - -static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y) -{ - if (x > c->max_x || !c->started) c->max_x = x; - if (y > c->max_y || !c->started) c->max_y = y; - if (x < c->min_x || !c->started) c->min_x = x; - if (y < c->min_y || !c->started) c->min_y = y; - c->started = 1; -} - -static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1) -{ - if (c->bounds) { - stbtt__track_vertex(c, x, y); - if (type == STBTT_vcubic) { - stbtt__track_vertex(c, cx, cy); - stbtt__track_vertex(c, cx1, cy1); - } - } else { - stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy); - c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1; - c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1; - } - c->num_vertices++; -} - -static void stbtt__csctx_close_shape(stbtt__csctx *ctx) -{ - if (ctx->first_x != ctx->x || ctx->first_y != ctx->y) - stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0); -} - -static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy) -{ - stbtt__csctx_close_shape(ctx); - ctx->first_x = ctx->x = ctx->x + dx; - ctx->first_y = ctx->y = ctx->y + dy; - stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); -} - -static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy) -{ - ctx->x += dx; - ctx->y += dy; - stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); -} - -static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) -{ - float cx1 = ctx->x + dx1; - float cy1 = ctx->y + dy1; - float cx2 = cx1 + dx2; - float cy2 = cy1 + dy2; - ctx->x = cx2 + dx3; - ctx->y = cy2 + dy3; - stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2); -} - -static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n) -{ - int count = stbtt__cff_index_count(&idx); - int bias = 107; - if (count >= 33900) - bias = 32768; - else if (count >= 1240) - bias = 1131; - n += bias; - if (n < 0 || n >= count) - return stbtt__new_buf(NULL, 0); - return stbtt__cff_index_get(idx, n); -} - -static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index) -{ - stbtt__buf fdselect = info->fdselect; - int nranges, start, end, v, fmt, fdselector = -1, i; - - stbtt__buf_seek(&fdselect, 0); - fmt = stbtt__buf_get8(&fdselect); - if (fmt == 0) { - // untested - stbtt__buf_skip(&fdselect, glyph_index); - fdselector = stbtt__buf_get8(&fdselect); - } else if (fmt == 3) { - nranges = stbtt__buf_get16(&fdselect); - start = stbtt__buf_get16(&fdselect); - for (i = 0; i < nranges; i++) { - v = stbtt__buf_get8(&fdselect); - end = stbtt__buf_get16(&fdselect); - if (glyph_index >= start && glyph_index < end) { - fdselector = v; - break; - } - start = end; - } - } - if (fdselector == -1) stbtt__new_buf(NULL, 0); - return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector)); -} - -static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c) -{ - int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; - int has_subrs = 0, clear_stack; - float s[48]; - stbtt__buf subr_stack[10], subrs = info->subrs, b; - float f; - -#define STBTT__CSERR(s) (0) - - // this currently ignores the initial width value, which isn't needed if we have hmtx - b = stbtt__cff_index_get(info->charstrings, glyph_index); - while (b.cursor < b.size) { - i = 0; - clear_stack = 1; - b0 = stbtt__buf_get8(&b); - switch (b0) { - // @TODO implement hinting - case 0x13: // hintmask - case 0x14: // cntrmask - if (in_header) - maskbits += (sp / 2); // implicit "vstem" - in_header = 0; - stbtt__buf_skip(&b, (maskbits + 7) / 8); - break; - - case 0x01: // hstem - case 0x03: // vstem - case 0x12: // hstemhm - case 0x17: // vstemhm - maskbits += (sp / 2); - break; - - case 0x15: // rmoveto - in_header = 0; - if (sp < 2) return STBTT__CSERR("rmoveto stack"); - stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); - break; - case 0x04: // vmoveto - in_header = 0; - if (sp < 1) return STBTT__CSERR("vmoveto stack"); - stbtt__csctx_rmove_to(c, 0, s[sp-1]); - break; - case 0x16: // hmoveto - in_header = 0; - if (sp < 1) return STBTT__CSERR("hmoveto stack"); - stbtt__csctx_rmove_to(c, s[sp-1], 0); - break; - - case 0x05: // rlineto - if (sp < 2) return STBTT__CSERR("rlineto stack"); - for (; i + 1 < sp; i += 2) - stbtt__csctx_rline_to(c, s[i], s[i+1]); - break; - - // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical - // starting from a different place. - - case 0x07: // vlineto - if (sp < 1) return STBTT__CSERR("vlineto stack"); - goto vlineto; - case 0x06: // hlineto - if (sp < 1) return STBTT__CSERR("hlineto stack"); - for (;;) { - if (i >= sp) break; - stbtt__csctx_rline_to(c, s[i], 0); - i++; - vlineto: - if (i >= sp) break; - stbtt__csctx_rline_to(c, 0, s[i]); - i++; - } - break; - - case 0x1F: // hvcurveto - if (sp < 4) return STBTT__CSERR("hvcurveto stack"); - goto hvcurveto; - case 0x1E: // vhcurveto - if (sp < 4) return STBTT__CSERR("vhcurveto stack"); - for (;;) { - if (i + 3 >= sp) break; - stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f); - i += 4; - hvcurveto: - if (i + 3 >= sp) break; - stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]); - i += 4; - } - break; - - case 0x08: // rrcurveto - if (sp < 6) return STBTT__CSERR("rcurveline stack"); - for (; i + 5 < sp; i += 6) - stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); - break; - - case 0x18: // rcurveline - if (sp < 8) return STBTT__CSERR("rcurveline stack"); - for (; i + 5 < sp - 2; i += 6) - stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); - if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack"); - stbtt__csctx_rline_to(c, s[i], s[i+1]); - break; - - case 0x19: // rlinecurve - if (sp < 8) return STBTT__CSERR("rlinecurve stack"); - for (; i + 1 < sp - 6; i += 2) - stbtt__csctx_rline_to(c, s[i], s[i+1]); - if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack"); - stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); - break; - - case 0x1A: // vvcurveto - case 0x1B: // hhcurveto - if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); - f = 0.0; - if (sp & 1) { f = s[i]; i++; } - for (; i + 3 < sp; i += 4) { - if (b0 == 0x1B) - stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0); - else - stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]); - f = 0.0; - } - break; - - case 0x0A: // callsubr - if (!has_subrs) { - if (info->fdselect.size) - subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); - has_subrs = 1; - } - // FALLTHROUGH - case 0x1D: // callgsubr - if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); - v = (int) s[--sp]; - if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); - subr_stack[subr_stack_height++] = b; - b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v); - if (b.size == 0) return STBTT__CSERR("subr not found"); - b.cursor = 0; - clear_stack = 0; - break; - - case 0x0B: // return - if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); - b = subr_stack[--subr_stack_height]; - clear_stack = 0; - break; - - case 0x0E: // endchar - stbtt__csctx_close_shape(c); - return 1; - - case 0x0C: { // two-byte escape - float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; - float dx, dy; - int b1 = stbtt__buf_get8(&b); - switch (b1) { - // @TODO These "flex" implementations ignore the flex-depth and resolution, - // and always draw beziers. - case 0x22: // hflex - if (sp < 7) return STBTT__CSERR("hflex stack"); - dx1 = s[0]; - dx2 = s[1]; - dy2 = s[2]; - dx3 = s[3]; - dx4 = s[4]; - dx5 = s[5]; - dx6 = s[6]; - stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0); - stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); - break; - - case 0x23: // flex - if (sp < 13) return STBTT__CSERR("flex stack"); - dx1 = s[0]; - dy1 = s[1]; - dx2 = s[2]; - dy2 = s[3]; - dx3 = s[4]; - dy3 = s[5]; - dx4 = s[6]; - dy4 = s[7]; - dx5 = s[8]; - dy5 = s[9]; - dx6 = s[10]; - dy6 = s[11]; - //fd is s[12] - stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); - stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); - break; - - case 0x24: // hflex1 - if (sp < 9) return STBTT__CSERR("hflex1 stack"); - dx1 = s[0]; - dy1 = s[1]; - dx2 = s[2]; - dy2 = s[3]; - dx3 = s[4]; - dx4 = s[5]; - dx5 = s[6]; - dy5 = s[7]; - dx6 = s[8]; - stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0); - stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); - break; - - case 0x25: // flex1 - if (sp < 11) return STBTT__CSERR("flex1 stack"); - dx1 = s[0]; - dy1 = s[1]; - dx2 = s[2]; - dy2 = s[3]; - dx3 = s[4]; - dy3 = s[5]; - dx4 = s[6]; - dy4 = s[7]; - dx5 = s[8]; - dy5 = s[9]; - dx6 = dy6 = s[10]; - dx = dx1+dx2+dx3+dx4+dx5; - dy = dy1+dy2+dy3+dy4+dy5; - if (STBTT_fabs(dx) > STBTT_fabs(dy)) - dy6 = -dy; - else - dx6 = -dx; - stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); - stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); - break; - - default: - return STBTT__CSERR("unimplemented"); - } - } break; - - default: - if (b0 != 255 && b0 != 28 && b0 < 32) - return STBTT__CSERR("reserved operator"); - - // push immediate - if (b0 == 255) { - f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; - } else { - stbtt__buf_skip(&b, -1); - f = (float)(stbtt_int16)stbtt__cff_int(&b); - } - if (sp >= 48) return STBTT__CSERR("push stack overflow"); - s[sp++] = f; - clear_stack = 0; - break; - } - if (clear_stack) sp = 0; - } - return STBTT__CSERR("no endchar"); - -#undef STBTT__CSERR -} - -static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) -{ - // runs the charstring twice, once to count and once to output (to avoid realloc) - stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); - stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); - if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { - *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata); - output_ctx.pvertices = *pvertices; - if (stbtt__run_charstring(info, glyph_index, &output_ctx)) { - STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices); - return output_ctx.num_vertices; - } - } - *pvertices = NULL; - return 0; -} - -static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) -{ - stbtt__csctx c = STBTT__CSCTX_INIT(1); - int r = stbtt__run_charstring(info, glyph_index, &c); - if (x0) *x0 = r ? c.min_x : 0; - if (y0) *y0 = r ? c.min_y : 0; - if (x1) *x1 = r ? c.max_x : 0; - if (y1) *y1 = r ? c.max_y : 0; - return r ? c.num_vertices : 0; -} - -STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) -{ - if (!info->cff.size) - return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices); - else - return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices); -} - -STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) -{ - stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); - if (glyph_index < numOfLongHorMetrics) { - if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); - if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); - } else { - if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); - if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); - } -} - -STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) -{ - stbtt_uint8 *data = info->data + info->kern; - - // we only look at the first table. it must be 'horizontal' and format 0. - if (!info->kern) - return 0; - if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 - return 0; - if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format - return 0; - - return ttUSHORT(data+10); -} - -STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length) -{ - stbtt_uint8 *data = info->data + info->kern; - int k, length; - - // we only look at the first table. it must be 'horizontal' and format 0. - if (!info->kern) - return 0; - if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 - return 0; - if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format - return 0; - - length = ttUSHORT(data+10); - if (table_length < length) - length = table_length; - - for (k = 0; k < length; k++) - { - table[k].glyph1 = ttUSHORT(data+18+(k*6)); - table[k].glyph2 = ttUSHORT(data+20+(k*6)); - table[k].advance = ttSHORT(data+22+(k*6)); - } - - return length; -} - -static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) -{ - stbtt_uint8 *data = info->data + info->kern; - stbtt_uint32 needle, straw; - int l, r, m; - - // we only look at the first table. it must be 'horizontal' and format 0. - if (!info->kern) - return 0; - if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 - return 0; - if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format - return 0; - - l = 0; - r = ttUSHORT(data+10) - 1; - needle = glyph1 << 16 | glyph2; - while (l <= r) { - m = (l + r) >> 1; - straw = ttULONG(data+18+(m*6)); // note: unaligned read - if (needle < straw) - r = m - 1; - else if (needle > straw) - l = m + 1; - else - return ttSHORT(data+22+(m*6)); - } - return 0; -} - -static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph) -{ - stbtt_uint16 coverageFormat = ttUSHORT(coverageTable); - switch (coverageFormat) { - case 1: { - stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); - - // Binary search. - stbtt_int32 l=0, r=glyphCount-1, m; - int straw, needle=glyph; - while (l <= r) { - stbtt_uint8 *glyphArray = coverageTable + 4; - stbtt_uint16 glyphID; - m = (l + r) >> 1; - glyphID = ttUSHORT(glyphArray + 2 * m); - straw = glyphID; - if (needle < straw) - r = m - 1; - else if (needle > straw) - l = m + 1; - else { - return m; - } - } - break; - } - - case 2: { - stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); - stbtt_uint8 *rangeArray = coverageTable + 4; - - // Binary search. - stbtt_int32 l=0, r=rangeCount-1, m; - int strawStart, strawEnd, needle=glyph; - while (l <= r) { - stbtt_uint8 *rangeRecord; - m = (l + r) >> 1; - rangeRecord = rangeArray + 6 * m; - strawStart = ttUSHORT(rangeRecord); - strawEnd = ttUSHORT(rangeRecord + 2); - if (needle < strawStart) - r = m - 1; - else if (needle > strawEnd) - l = m + 1; - else { - stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4); - return startCoverageIndex + glyph - strawStart; - } - } - break; - } - - default: return -1; // unsupported - } - - return -1; -} - -static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) -{ - stbtt_uint16 classDefFormat = ttUSHORT(classDefTable); - switch (classDefFormat) - { - case 1: { - stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2); - stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4); - stbtt_uint8 *classDef1ValueArray = classDefTable + 6; - - if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount) - return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID)); - break; - } - - case 2: { - stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); - stbtt_uint8 *classRangeRecords = classDefTable + 4; - - // Binary search. - stbtt_int32 l=0, r=classRangeCount-1, m; - int strawStart, strawEnd, needle=glyph; - while (l <= r) { - stbtt_uint8 *classRangeRecord; - m = (l + r) >> 1; - classRangeRecord = classRangeRecords + 6 * m; - strawStart = ttUSHORT(classRangeRecord); - strawEnd = ttUSHORT(classRangeRecord + 2); - if (needle < strawStart) - r = m - 1; - else if (needle > strawEnd) - l = m + 1; - else - return (stbtt_int32)ttUSHORT(classRangeRecord + 4); - } - break; - } - - default: - return -1; // Unsupported definition type, return an error. - } - - // "All glyphs not assigned to a class fall into class 0". (OpenType spec) - return 0; -} - -// Define to STBTT_assert(x) if you want to break on unimplemented formats. -#define STBTT_GPOS_TODO_assert(x) - -static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) -{ - stbtt_uint16 lookupListOffset; - stbtt_uint8 *lookupList; - stbtt_uint16 lookupCount; - stbtt_uint8 *data; - stbtt_int32 i, sti; - - if (!info->gpos) return 0; - - data = info->data + info->gpos; - - if (ttUSHORT(data+0) != 1) return 0; // Major version 1 - if (ttUSHORT(data+2) != 0) return 0; // Minor version 0 - - lookupListOffset = ttUSHORT(data+8); - lookupList = data + lookupListOffset; - lookupCount = ttUSHORT(lookupList); - - for (i=0; i= pairSetCount) return 0; - - needle=glyph2; - r=pairValueCount-1; - l=0; - - // Binary search. - while (l <= r) { - stbtt_uint16 secondGlyph; - stbtt_uint8 *pairValue; - m = (l + r) >> 1; - pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m; - secondGlyph = ttUSHORT(pairValue); - straw = secondGlyph; - if (needle < straw) - r = m - 1; - else if (needle > straw) - l = m + 1; - else { - stbtt_int16 xAdvance = ttSHORT(pairValue + 2); - return xAdvance; - } - } - } else - return 0; - break; - } - - case 2: { - stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); - stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); - if (valueFormat1 == 4 && valueFormat2 == 0) { // Support more formats? - stbtt_uint16 classDef1Offset = ttUSHORT(table + 8); - stbtt_uint16 classDef2Offset = ttUSHORT(table + 10); - int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1); - int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2); - - stbtt_uint16 class1Count = ttUSHORT(table + 12); - stbtt_uint16 class2Count = ttUSHORT(table + 14); - stbtt_uint8 *class1Records, *class2Records; - stbtt_int16 xAdvance; - - if (glyph1class < 0 || glyph1class >= class1Count) return 0; // malformed - if (glyph2class < 0 || glyph2class >= class2Count) return 0; // malformed - - class1Records = table + 16; - class2Records = class1Records + 2 * (glyph1class * class2Count); - xAdvance = ttSHORT(class2Records + 2 * glyph2class); - return xAdvance; - } else - return 0; - break; - } - - default: - return 0; // Unsupported position format - } - } - } - - return 0; -} - -STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) -{ - int xAdvance = 0; - - if (info->gpos) - xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2); - else if (info->kern) - xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2); - - return xAdvance; -} - -STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) -{ - if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs - return 0; - return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); -} - -STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) -{ - stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); -} - -STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) -{ - if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); - if (descent) *descent = ttSHORT(info->data+info->hhea + 6); - if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); -} - -STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap) -{ - int tab = stbtt__find_table(info->data, info->fontstart, "OS/2"); - if (!tab) - return 0; - if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68); - if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70); - if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72); - return 1; -} - -STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1) -{ - *x0 = ttSHORT(info->data + info->head + 36); - *y0 = ttSHORT(info->data + info->head + 38); - *x1 = ttSHORT(info->data + info->head + 40); - *y1 = ttSHORT(info->data + info->head + 42); -} - -STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) -{ - int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); - return (float) height / fheight; -} - -STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels) -{ - int unitsPerEm = ttUSHORT(info->data + info->head + 18); - return pixels / unitsPerEm; -} - -STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) -{ - STBTT_free(v, info->userdata); -} - -STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) -{ - int i; - stbtt_uint8 *data = info->data; - stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info); - - int numEntries = ttUSHORT(svg_doc_list); - stbtt_uint8 *svg_docs = svg_doc_list + 2; - - for(i=0; i= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2))) - return svg_doc; - } - return 0; -} - -STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg) -{ - stbtt_uint8 *data = info->data; - stbtt_uint8 *svg_doc; - - if (info->svg == 0) - return 0; - - svg_doc = stbtt_FindSVGDoc(info, gl); - if (svg_doc != NULL) { - *svg = (char *) data + info->svg + ttULONG(svg_doc + 4); - return ttULONG(svg_doc + 8); - } else { - return 0; - } -} - -STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg) -{ - return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); -} - -////////////////////////////////////////////////////////////////////////////// -// -// antialiasing software rasterizer -// - -STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) -{ - int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning - if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { - // e.g. space character - if (ix0) *ix0 = 0; - if (iy0) *iy0 = 0; - if (ix1) *ix1 = 0; - if (iy1) *iy1 = 0; - } else { - // move to integral bboxes (treating pixels as little squares, what pixels get touched)? - if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); - if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); - if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); - if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y); - } -} - -STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) -{ - stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); -} - -STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) -{ - stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); -} - -STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) -{ - stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); -} - -////////////////////////////////////////////////////////////////////////////// -// -// Rasterizer - -typedef struct stbtt__hheap_chunk -{ - struct stbtt__hheap_chunk *next; -} stbtt__hheap_chunk; - -typedef struct stbtt__hheap -{ - struct stbtt__hheap_chunk *head; - void *first_free; - int num_remaining_in_head_chunk; -} stbtt__hheap; - -static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata) -{ - if (hh->first_free) { - void *p = hh->first_free; - hh->first_free = * (void **) p; - return p; - } else { - if (hh->num_remaining_in_head_chunk == 0) { - int count = (size < 32 ? 2000 : size < 128 ? 800 : 100); - stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata); - if (c == NULL) - return NULL; - c->next = hh->head; - hh->head = c; - hh->num_remaining_in_head_chunk = count; - } - --hh->num_remaining_in_head_chunk; - return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk; - } -} - -static void stbtt__hheap_free(stbtt__hheap *hh, void *p) -{ - *(void **) p = hh->first_free; - hh->first_free = p; -} - -static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) -{ - stbtt__hheap_chunk *c = hh->head; - while (c) { - stbtt__hheap_chunk *n = c->next; - STBTT_free(c, userdata); - c = n; - } -} - -typedef struct stbtt__edge { - float x0,y0, x1,y1; - int invert; -} stbtt__edge; - - -typedef struct stbtt__active_edge -{ - struct stbtt__active_edge *next; - #if STBTT_RASTERIZER_VERSION==1 - int x,dx; - float ey; - int direction; - #elif STBTT_RASTERIZER_VERSION==2 - float fx,fdx,fdy; - float direction; - float sy; - float ey; - #else - #error "Unrecognized value of STBTT_RASTERIZER_VERSION" - #endif -} stbtt__active_edge; - -#if STBTT_RASTERIZER_VERSION == 1 -#define STBTT_FIXSHIFT 10 -#define STBTT_FIX (1 << STBTT_FIXSHIFT) -#define STBTT_FIXMASK (STBTT_FIX-1) - -static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) -{ - stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); - float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); - STBTT_assert(z != NULL); - if (!z) return z; - - // round dx down to avoid overshooting - if (dxdy < 0) - z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); - else - z->dx = STBTT_ifloor(STBTT_FIX * dxdy); - - z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount - z->x -= off_x * STBTT_FIX; - - z->ey = e->y1; - z->next = 0; - z->direction = e->invert ? 1 : -1; - return z; -} -#elif STBTT_RASTERIZER_VERSION == 2 -static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) -{ - stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); - float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); - STBTT_assert(z != NULL); - //STBTT_assert(e->y0 <= start_point); - if (!z) return z; - z->fdx = dxdy; - z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; - z->fx = e->x0 + dxdy * (start_point - e->y0); - z->fx -= off_x; - z->direction = e->invert ? 1.0f : -1.0f; - z->sy = e->y0; - z->ey = e->y1; - z->next = 0; - return z; -} -#else -#error "Unrecognized value of STBTT_RASTERIZER_VERSION" -#endif - -#if STBTT_RASTERIZER_VERSION == 1 -// note: this routine clips fills that extend off the edges... ideally this -// wouldn't happen, but it could happen if the truetype glyph bounding boxes -// are wrong, or if the user supplies a too-small bitmap -static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) -{ - // non-zero winding fill - int x0=0, w=0; - - while (e) { - if (w == 0) { - // if we're currently at zero, we need to record the edge start point - x0 = e->x; w += e->direction; - } else { - int x1 = e->x; w += e->direction; - // if we went to zero, we need to draw - if (w == 0) { - int i = x0 >> STBTT_FIXSHIFT; - int j = x1 >> STBTT_FIXSHIFT; - - if (i < len && j >= 0) { - if (i == j) { - // x0,x1 are the same pixel, so compute combined coverage - scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); - } else { - if (i >= 0) // add antialiasing for x0 - scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); - else - i = -1; // clip - - if (j < len) // add antialiasing for x1 - scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); - else - j = len; // clip - - for (++i; i < j; ++i) // fill pixels between x0 and x1 - scanline[i] = scanline[i] + (stbtt_uint8) max_weight; - } - } - } - } - - e = e->next; - } -} - -static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) -{ - stbtt__hheap hh = { 0, 0, 0 }; - stbtt__active_edge *active = NULL; - int y,j=0; - int max_weight = (255 / vsubsample); // weight per vertical scanline - int s; // vertical subsample index - unsigned char scanline_data[512], *scanline; - - if (result->w > 512) - scanline = (unsigned char *) STBTT_malloc(result->w, userdata); - else - scanline = scanline_data; - - y = off_y * vsubsample; - e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; - - while (j < result->h) { - STBTT_memset(scanline, 0, result->w); - for (s=0; s < vsubsample; ++s) { - // find center of pixel for this scanline - float scan_y = y + 0.5f; - stbtt__active_edge **step = &active; - - // update all active edges; - // remove all active edges that terminate before the center of this scanline - while (*step) { - stbtt__active_edge * z = *step; - if (z->ey <= scan_y) { - *step = z->next; // delete from list - STBTT_assert(z->direction); - z->direction = 0; - stbtt__hheap_free(&hh, z); - } else { - z->x += z->dx; // advance to position for current scanline - step = &((*step)->next); // advance through list - } - } - - // resort the list if needed - for(;;) { - int changed=0; - step = &active; - while (*step && (*step)->next) { - if ((*step)->x > (*step)->next->x) { - stbtt__active_edge *t = *step; - stbtt__active_edge *q = t->next; - - t->next = q->next; - q->next = t; - *step = q; - changed = 1; - } - step = &(*step)->next; - } - if (!changed) break; - } - - // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline - while (e->y0 <= scan_y) { - if (e->y1 > scan_y) { - stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); - if (z != NULL) { - // find insertion point - if (active == NULL) - active = z; - else if (z->x < active->x) { - // insert at front - z->next = active; - active = z; - } else { - // find thing to insert AFTER - stbtt__active_edge *p = active; - while (p->next && p->next->x < z->x) - p = p->next; - // at this point, p->next->x is NOT < z->x - z->next = p->next; - p->next = z; - } - } - } - ++e; - } - - // now process all active edges in XOR fashion - if (active) - stbtt__fill_active_edges(scanline, result->w, active, max_weight); - - ++y; - } - STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); - ++j; - } - - stbtt__hheap_cleanup(&hh, userdata); - - if (scanline != scanline_data) - STBTT_free(scanline, userdata); -} - -#elif STBTT_RASTERIZER_VERSION == 2 - -// the edge passed in here does not cross the vertical line at x or the vertical line at x+1 -// (i.e. it has already been clipped to those) -static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) -{ - if (y0 == y1) return; - STBTT_assert(y0 < y1); - STBTT_assert(e->sy <= e->ey); - if (y0 > e->ey) return; - if (y1 < e->sy) return; - if (y0 < e->sy) { - x0 += (x1-x0) * (e->sy - y0) / (y1-y0); - y0 = e->sy; - } - if (y1 > e->ey) { - x1 += (x1-x0) * (e->ey - y1) / (y1-y0); - y1 = e->ey; - } - - if (x0 == x) - STBTT_assert(x1 <= x+1); - else if (x0 == x+1) - STBTT_assert(x1 >= x); - else if (x0 <= x) - STBTT_assert(x1 <= x); - else if (x0 >= x+1) - STBTT_assert(x1 >= x+1); - else - STBTT_assert(x1 >= x && x1 <= x+1); - - if (x0 <= x && x1 <= x) - scanline[x] += e->direction * (y1-y0); - else if (x0 >= x+1 && x1 >= x+1) - ; - else { - STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); - scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position - } -} - -static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width) -{ - STBTT_assert(top_width >= 0); - STBTT_assert(bottom_width >= 0); - return (top_width + bottom_width) / 2.0f * height; -} - -static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1) -{ - return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0); -} - -static float stbtt__sized_triangle_area(float height, float width) -{ - return height * width / 2; -} - -static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top) -{ - float y_bottom = y_top+1; - - while (e) { - // brute force every pixel - - // compute intersection points with top & bottom - STBTT_assert(e->ey >= y_top); - - if (e->fdx == 0) { - float x0 = e->fx; - if (x0 < len) { - if (x0 >= 0) { - stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom); - stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom); - } else { - stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom); - } - } - } else { - float x0 = e->fx; - float dx = e->fdx; - float xb = x0 + dx; - float x_top, x_bottom; - float sy0,sy1; - float dy = e->fdy; - STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); - - // compute endpoints of line segment clipped to this scanline (if the - // line segment starts on this scanline. x0 is the intersection of the - // line with y_top, but that may be off the line segment. - if (e->sy > y_top) { - x_top = x0 + dx * (e->sy - y_top); - sy0 = e->sy; - } else { - x_top = x0; - sy0 = y_top; - } - if (e->ey < y_bottom) { - x_bottom = x0 + dx * (e->ey - y_top); - sy1 = e->ey; - } else { - x_bottom = xb; - sy1 = y_bottom; - } - - if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { - // from here on, we don't have to range check x values - - if ((int) x_top == (int) x_bottom) { - float height; - // simple case, only spans one pixel - int x = (int) x_top; - height = (sy1 - sy0) * e->direction; - STBTT_assert(x >= 0 && x < len); - scanline[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f); - scanline_fill[x] += height; // everything right of this pixel is filled - } else { - int x,x1,x2; - float y_crossing, y_final, step, sign, area; - // covers 2+ pixels - if (x_top > x_bottom) { - // flip scanline vertically; signed area is the same - float t; - sy0 = y_bottom - (sy0 - y_top); - sy1 = y_bottom - (sy1 - y_top); - t = sy0, sy0 = sy1, sy1 = t; - t = x_bottom, x_bottom = x_top, x_top = t; - dx = -dx; - dy = -dy; - t = x0, x0 = xb, xb = t; - } - STBTT_assert(dy >= 0); - STBTT_assert(dx >= 0); - - x1 = (int) x_top; - x2 = (int) x_bottom; - // compute intersection with y axis at x1+1 - y_crossing = y_top + dy * (x1+1 - x0); - - // compute intersection with y axis at x2 - y_final = y_top + dy * (x2 - x0); - - // x1 x_top x2 x_bottom - // y_top +------|-----+------------+------------+--------|---+------------+ - // | | | | | | - // | | | | | | - // sy0 | Txxxxx|............|............|............|............| - // y_crossing | *xxxxx.......|............|............|............| - // | | xxxxx..|............|............|............| - // | | /- xx*xxxx........|............|............| - // | | dy < | xxxxxx..|............|............| - // y_final | | \- | xx*xxx.........|............| - // sy1 | | | | xxxxxB...|............| - // | | | | | | - // | | | | | | - // y_bottom +------------+------------+------------+------------+------------+ - // - // goal is to measure the area covered by '.' in each pixel - - // if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 - // @TODO: maybe test against sy1 rather than y_bottom? - if (y_crossing > y_bottom) - y_crossing = y_bottom; - - sign = e->direction; - - // area of the rectangle covered from sy0..y_crossing - area = sign * (y_crossing-sy0); - - // area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) - scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top); - - // check if final y_crossing is blown up; no test case for this - if (y_final > y_bottom) { - y_final = y_bottom; - dy = (y_final - y_crossing ) / (x2 - (x1+1)); // if denom=0, y_final = y_crossing, so y_final <= y_bottom - } - - // in second pixel, area covered by line segment found in first pixel - // is always a rectangle 1 wide * the height of that line segment; this - // is exactly what the variable 'area' stores. it also gets a contribution - // from the line segment within it. the THIRD pixel will get the first - // pixel's rectangle contribution, the second pixel's rectangle contribution, - // and its own contribution. the 'own contribution' is the same in every pixel except - // the leftmost and rightmost, a trapezoid that slides down in each pixel. - // the second pixel's contribution to the third pixel will be the - // rectangle 1 wide times the height change in the second pixel, which is dy. - - step = sign * dy * 1; // dy is dy/dx, change in y for every 1 change in x, - // which multiplied by 1-pixel-width is how much pixel area changes for each step in x - // so the area advances by 'step' every time - - for (x = x1+1; x < x2; ++x) { - scanline[x] += area + step/2; // area of trapezoid is 1*step/2 - area += step; - } - STBTT_assert(STBTT_fabs(area) <= 1.01f); // accumulated error from area += step unless we round step down - STBTT_assert(sy1 > y_final-0.01f); - - // area covered in the last pixel is the rectangle from all the pixels to the left, - // plus the trapezoid filled by the line segment in this pixel all the way to the right edge - scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f); - - // the rest of the line is filled based on the total height of the line segment in this pixel - scanline_fill[x2] += sign * (sy1-sy0); - } - } else { - // if edge goes outside of box we're drawing, we require - // clipping logic. since this does not match the intended use - // of this library, we use a different, very slow brute - // force implementation - // note though that this does happen some of the time because - // x_top and x_bottom can be extrapolated at the top & bottom of - // the shape and actually lie outside the bounding box - int x; - for (x=0; x < len; ++x) { - // cases: - // - // there can be up to two intersections with the pixel. any intersection - // with left or right edges can be handled by splitting into two (or three) - // regions. intersections with top & bottom do not necessitate case-wise logic. - // - // the old way of doing this found the intersections with the left & right edges, - // then used some simple logic to produce up to three segments in sorted order - // from top-to-bottom. however, this had a problem: if an x edge was epsilon - // across the x border, then the corresponding y position might not be distinct - // from the other y segment, and it might ignored as an empty segment. to avoid - // that, we need to explicitly produce segments based on x positions. - - // rename variables to clearly-defined pairs - float y0 = y_top; - float x1 = (float) (x); - float x2 = (float) (x+1); - float x3 = xb; - float y3 = y_bottom; - - // x = e->x + e->dx * (y-y_top) - // (y-y_top) = (x - e->x) / e->dx - // y = (x - e->x) / e->dx + y_top - float y1 = (x - x0) / dx + y_top; - float y2 = (x+1 - x0) / dx + y_top; - - if (x0 < x1 && x3 > x2) { // three segments descending down-right - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); - stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); - stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else if (x3 < x1 && x0 > x2) { // three segments descending down-left - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); - stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); - stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); - stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); - stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); - stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); - stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else { // one segment - stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); - } - } - } - } - e = e->next; - } -} - -// directly AA rasterize edges w/o supersampling -static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) -{ - stbtt__hheap hh = { 0, 0, 0 }; - stbtt__active_edge *active = NULL; - int y,j=0, i; - float scanline_data[129], *scanline, *scanline2; - - STBTT__NOTUSED(vsubsample); - - if (result->w > 64) - scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata); - else - scanline = scanline_data; - - scanline2 = scanline + result->w; - - y = off_y; - e[n].y0 = (float) (off_y + result->h) + 1; - - while (j < result->h) { - // find center of pixel for this scanline - float scan_y_top = y + 0.0f; - float scan_y_bottom = y + 1.0f; - stbtt__active_edge **step = &active; - - STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); - STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); - - // update all active edges; - // remove all active edges that terminate before the top of this scanline - while (*step) { - stbtt__active_edge * z = *step; - if (z->ey <= scan_y_top) { - *step = z->next; // delete from list - STBTT_assert(z->direction); - z->direction = 0; - stbtt__hheap_free(&hh, z); - } else { - step = &((*step)->next); // advance through list - } - } - - // insert all edges that start before the bottom of this scanline - while (e->y0 <= scan_y_bottom) { - if (e->y0 != e->y1) { - stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); - if (z != NULL) { - if (j == 0 && off_y != 0) { - if (z->ey < scan_y_top) { - // this can happen due to subpixel positioning and some kind of fp rounding error i think - z->ey = scan_y_top; - } - } - STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds - // insert at front - z->next = active; - active = z; - } - } - ++e; - } - - // now process all active edges - if (active) - stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); - - { - float sum = 0; - for (i=0; i < result->w; ++i) { - float k; - int m; - sum += scanline2[i]; - k = scanline[i] + sum; - k = (float) STBTT_fabs(k)*255 + 0.5f; - m = (int) k; - if (m > 255) m = 255; - result->pixels[j*result->stride + i] = (unsigned char) m; - } - } - // advance all the edges - step = &active; - while (*step) { - stbtt__active_edge *z = *step; - z->fx += z->fdx; // advance to position for current scanline - step = &((*step)->next); // advance through list - } - - ++y; - ++j; - } - - stbtt__hheap_cleanup(&hh, userdata); - - if (scanline != scanline_data) - STBTT_free(scanline, userdata); -} -#else -#error "Unrecognized value of STBTT_RASTERIZER_VERSION" -#endif - -#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0) - -static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n) -{ - int i,j; - for (i=1; i < n; ++i) { - stbtt__edge t = p[i], *a = &t; - j = i; - while (j > 0) { - stbtt__edge *b = &p[j-1]; - int c = STBTT__COMPARE(a,b); - if (!c) break; - p[j] = p[j-1]; - --j; - } - if (i != j) - p[j] = t; - } -} - -static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n) -{ - /* threshold for transitioning to insertion sort */ - while (n > 12) { - stbtt__edge t; - int c01,c12,c,m,i,j; - - /* compute median of three */ - m = n >> 1; - c01 = STBTT__COMPARE(&p[0],&p[m]); - c12 = STBTT__COMPARE(&p[m],&p[n-1]); - /* if 0 >= mid >= end, or 0 < mid < end, then use mid */ - if (c01 != c12) { - /* otherwise, we'll need to swap something else to middle */ - int z; - c = STBTT__COMPARE(&p[0],&p[n-1]); - /* 0>mid && midn => n; 0 0 */ - /* 0n: 0>n => 0; 0 n */ - z = (c == c12) ? 0 : n-1; - t = p[z]; - p[z] = p[m]; - p[m] = t; - } - /* now p[m] is the median-of-three */ - /* swap it to the beginning so it won't move around */ - t = p[0]; - p[0] = p[m]; - p[m] = t; - - /* partition loop */ - i=1; - j=n-1; - for(;;) { - /* handling of equality is crucial here */ - /* for sentinels & efficiency with duplicates */ - for (;;++i) { - if (!STBTT__COMPARE(&p[i], &p[0])) break; - } - for (;;--j) { - if (!STBTT__COMPARE(&p[0], &p[j])) break; - } - /* make sure we haven't crossed */ - if (i >= j) break; - t = p[i]; - p[i] = p[j]; - p[j] = t; - - ++i; - --j; - } - /* recurse on smaller side, iterate on larger */ - if (j < (n-i)) { - stbtt__sort_edges_quicksort(p,j); - p = p+i; - n = n-i; - } else { - stbtt__sort_edges_quicksort(p+i, n-i); - n = j; - } - } -} - -static void stbtt__sort_edges(stbtt__edge *p, int n) -{ - stbtt__sort_edges_quicksort(p, n); - stbtt__sort_edges_ins_sort(p, n); -} - -typedef struct -{ - float x,y; -} stbtt__point; - -static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) -{ - float y_scale_inv = invert ? -scale_y : scale_y; - stbtt__edge *e; - int n,i,j,k,m; -#if STBTT_RASTERIZER_VERSION == 1 - int vsubsample = result->h < 8 ? 15 : 5; -#elif STBTT_RASTERIZER_VERSION == 2 - int vsubsample = 1; -#else - #error "Unrecognized value of STBTT_RASTERIZER_VERSION" -#endif - // vsubsample should divide 255 evenly; otherwise we won't reach full opacity - - // now we have to blow out the windings into explicit edge lists - n = 0; - for (i=0; i < windings; ++i) - n += wcount[i]; - - e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel - if (e == 0) return; - n = 0; - - m=0; - for (i=0; i < windings; ++i) { - stbtt__point *p = pts + m; - m += wcount[i]; - j = wcount[i]-1; - for (k=0; k < wcount[i]; j=k++) { - int a=k,b=j; - // skip the edge if horizontal - if (p[j].y == p[k].y) - continue; - // add edge from j to k to the list - e[n].invert = 0; - if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { - e[n].invert = 1; - a=j,b=k; - } - e[n].x0 = p[a].x * scale_x + shift_x; - e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample; - e[n].x1 = p[b].x * scale_x + shift_x; - e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; - ++n; - } - } - - // now sort the edges by their highest point (should snap to integer, and then by x) - //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); - stbtt__sort_edges(e, n); - - // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule - stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); - - STBTT_free(e, userdata); -} - -static void stbtt__add_point(stbtt__point *points, int n, float x, float y) -{ - if (!points) return; // during first pass, it's unallocated - points[n].x = x; - points[n].y = y; -} - -// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching -static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) -{ - // midpoint - float mx = (x0 + 2*x1 + x2)/4; - float my = (y0 + 2*y1 + y2)/4; - // versus directly drawn line - float dx = (x0+x2)/2 - mx; - float dy = (y0+y2)/2 - my; - if (n > 16) // 65536 segments on one curve better be enough! - return 1; - if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA - stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); - stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); - } else { - stbtt__add_point(points, *num_points,x2,y2); - *num_points = *num_points+1; - } - return 1; -} - -static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) -{ - // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough - float dx0 = x1-x0; - float dy0 = y1-y0; - float dx1 = x2-x1; - float dy1 = y2-y1; - float dx2 = x3-x2; - float dy2 = y3-y2; - float dx = x3-x0; - float dy = y3-y0; - float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); - float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); - float flatness_squared = longlen*longlen-shortlen*shortlen; - - if (n > 16) // 65536 segments on one curve better be enough! - return; - - if (flatness_squared > objspace_flatness_squared) { - float x01 = (x0+x1)/2; - float y01 = (y0+y1)/2; - float x12 = (x1+x2)/2; - float y12 = (y1+y2)/2; - float x23 = (x2+x3)/2; - float y23 = (y2+y3)/2; - - float xa = (x01+x12)/2; - float ya = (y01+y12)/2; - float xb = (x12+x23)/2; - float yb = (y12+y23)/2; - - float mx = (xa+xb)/2; - float my = (ya+yb)/2; - - stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1); - stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1); - } else { - stbtt__add_point(points, *num_points,x3,y3); - *num_points = *num_points+1; - } -} - -// returns number of contours -static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) -{ - stbtt__point *points=0; - int num_points=0; - - float objspace_flatness_squared = objspace_flatness * objspace_flatness; - int i,n=0,start=0, pass; - - // count how many "moves" there are to get the contour count - for (i=0; i < num_verts; ++i) - if (vertices[i].type == STBTT_vmove) - ++n; - - *num_contours = n; - if (n == 0) return 0; - - *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); - - if (*contour_lengths == 0) { - *num_contours = 0; - return 0; - } - - // make two passes through the points so we don't need to realloc - for (pass=0; pass < 2; ++pass) { - float x=0,y=0; - if (pass == 1) { - points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); - if (points == NULL) goto error; - } - num_points = 0; - n= -1; - for (i=0; i < num_verts; ++i) { - switch (vertices[i].type) { - case STBTT_vmove: - // start the next contour - if (n >= 0) - (*contour_lengths)[n] = num_points - start; - ++n; - start = num_points; - - x = vertices[i].x, y = vertices[i].y; - stbtt__add_point(points, num_points++, x,y); - break; - case STBTT_vline: - x = vertices[i].x, y = vertices[i].y; - stbtt__add_point(points, num_points++, x, y); - break; - case STBTT_vcurve: - stbtt__tesselate_curve(points, &num_points, x,y, - vertices[i].cx, vertices[i].cy, - vertices[i].x, vertices[i].y, - objspace_flatness_squared, 0); - x = vertices[i].x, y = vertices[i].y; - break; - case STBTT_vcubic: - stbtt__tesselate_cubic(points, &num_points, x,y, - vertices[i].cx, vertices[i].cy, - vertices[i].cx1, vertices[i].cy1, - vertices[i].x, vertices[i].y, - objspace_flatness_squared, 0); - x = vertices[i].x, y = vertices[i].y; - break; - } - } - (*contour_lengths)[n] = num_points - start; - } - - return points; -error: - STBTT_free(points, userdata); - STBTT_free(*contour_lengths, userdata); - *contour_lengths = 0; - *num_contours = 0; - return NULL; -} - -STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) -{ - float scale = scale_x > scale_y ? scale_y : scale_x; - int winding_count = 0; - int *winding_lengths = NULL; - stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); - if (windings) { - stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); - STBTT_free(winding_lengths, userdata); - STBTT_free(windings, userdata); - } -} - -STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) -{ - STBTT_free(bitmap, userdata); -} - -STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) -{ - int ix0,iy0,ix1,iy1; - stbtt__bitmap gbm; - stbtt_vertex *vertices; - int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); - - if (scale_x == 0) scale_x = scale_y; - if (scale_y == 0) { - if (scale_x == 0) { - STBTT_free(vertices, info->userdata); - return NULL; - } - scale_y = scale_x; - } - - stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); - - // now we get the size - gbm.w = (ix1 - ix0); - gbm.h = (iy1 - iy0); - gbm.pixels = NULL; // in case we error - - if (width ) *width = gbm.w; - if (height) *height = gbm.h; - if (xoff ) *xoff = ix0; - if (yoff ) *yoff = iy0; - - if (gbm.w && gbm.h) { - gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); - if (gbm.pixels) { - gbm.stride = gbm.w; - - stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); - } - } - STBTT_free(vertices, info->userdata); - return gbm.pixels; -} - -STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) -{ - return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); -} - -STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) -{ - int ix0,iy0; - stbtt_vertex *vertices; - int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); - stbtt__bitmap gbm; - - stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); - gbm.pixels = output; - gbm.w = out_w; - gbm.h = out_h; - gbm.stride = out_stride; - - if (gbm.w && gbm.h) - stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); - - STBTT_free(vertices, info->userdata); -} - -STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) -{ - stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); -} - -STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) -{ - return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); -} - -STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint) -{ - stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint)); -} - -STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) -{ - stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); -} - -STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) -{ - return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); -} - -STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) -{ - stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); -} - -////////////////////////////////////////////////////////////////////////////// -// -// bitmap baking -// -// This is SUPER-CRAPPY packing to keep source code small - -static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) - float pixel_height, // height of font in pixels - unsigned char *pixels, int pw, int ph, // bitmap to be filled in - int first_char, int num_chars, // characters to bake - stbtt_bakedchar *chardata) -{ - float scale; - int x,y,bottom_y, i; - stbtt_fontinfo f; - f.userdata = NULL; - if (!stbtt_InitFont(&f, data, offset)) - return -1; - STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels - x=y=1; - bottom_y = 1; - - scale = stbtt_ScaleForPixelHeight(&f, pixel_height); - - for (i=0; i < num_chars; ++i) { - int advance, lsb, x0,y0,x1,y1,gw,gh; - int g = stbtt_FindGlyphIndex(&f, first_char + i); - stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); - stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); - gw = x1-x0; - gh = y1-y0; - if (x + gw + 1 >= pw) - y = bottom_y, x = 1; // advance to next row - if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row - return -i; - STBTT_assert(x+gw < pw); - STBTT_assert(y+gh < ph); - stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); - chardata[i].x0 = (stbtt_int16) x; - chardata[i].y0 = (stbtt_int16) y; - chardata[i].x1 = (stbtt_int16) (x + gw); - chardata[i].y1 = (stbtt_int16) (y + gh); - chardata[i].xadvance = scale * advance; - chardata[i].xoff = (float) x0; - chardata[i].yoff = (float) y0; - x = x + gw + 1; - if (y+gh+1 > bottom_y) - bottom_y = y+gh+1; - } - return bottom_y; -} - -STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) -{ - float d3d_bias = opengl_fillrule ? 0 : -0.5f; - float ipw = 1.0f / pw, iph = 1.0f / ph; - const stbtt_bakedchar *b = chardata + char_index; - int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f); - int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f); - - q->x0 = round_x + d3d_bias; - q->y0 = round_y + d3d_bias; - q->x1 = round_x + b->x1 - b->x0 + d3d_bias; - q->y1 = round_y + b->y1 - b->y0 + d3d_bias; - - q->s0 = b->x0 * ipw; - q->t0 = b->y0 * iph; - q->s1 = b->x1 * ipw; - q->t1 = b->y1 * iph; - - *xpos += b->xadvance; -} - -////////////////////////////////////////////////////////////////////////////// -// -// rectangle packing replacement routines if you don't have stb_rect_pack.h -// - -#ifndef STB_RECT_PACK_VERSION - -typedef int stbrp_coord; - -//////////////////////////////////////////////////////////////////////////////////// -// // -// // -// COMPILER WARNING ?!?!? // -// // -// // -// if you get a compile warning due to these symbols being defined more than // -// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // -// // -//////////////////////////////////////////////////////////////////////////////////// - -typedef struct -{ - int width,height; - int x,y,bottom_y; -} stbrp_context; - -typedef struct -{ - unsigned char x; -} stbrp_node; - -struct stbrp_rect -{ - stbrp_coord x,y; - int id,w,h,was_packed; -}; - -static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes) -{ - con->width = pw; - con->height = ph; - con->x = 0; - con->y = 0; - con->bottom_y = 0; - STBTT__NOTUSED(nodes); - STBTT__NOTUSED(num_nodes); -} - -static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects) -{ - int i; - for (i=0; i < num_rects; ++i) { - if (con->x + rects[i].w > con->width) { - con->x = 0; - con->y = con->bottom_y; - } - if (con->y + rects[i].h > con->height) - break; - rects[i].x = con->x; - rects[i].y = con->y; - rects[i].was_packed = 1; - con->x += rects[i].w; - if (con->y + rects[i].h > con->bottom_y) - con->bottom_y = con->y + rects[i].h; - } - for ( ; i < num_rects; ++i) - rects[i].was_packed = 0; -} -#endif - -////////////////////////////////////////////////////////////////////////////// -// -// bitmap baking -// -// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If -// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. - -STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) -{ - stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context); - int num_nodes = pw - padding; - stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context); - - if (context == NULL || nodes == NULL) { - if (context != NULL) STBTT_free(context, alloc_context); - if (nodes != NULL) STBTT_free(nodes , alloc_context); - return 0; - } - - spc->user_allocator_context = alloc_context; - spc->width = pw; - spc->height = ph; - spc->pixels = pixels; - spc->pack_info = context; - spc->nodes = nodes; - spc->padding = padding; - spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw; - spc->h_oversample = 1; - spc->v_oversample = 1; - spc->skip_missing = 0; - - stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); - - if (pixels) - STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels - - return 1; -} - -STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc) -{ - STBTT_free(spc->nodes , spc->user_allocator_context); - STBTT_free(spc->pack_info, spc->user_allocator_context); -} - -STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample) -{ - STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE); - STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE); - if (h_oversample <= STBTT_MAX_OVERSAMPLE) - spc->h_oversample = h_oversample; - if (v_oversample <= STBTT_MAX_OVERSAMPLE) - spc->v_oversample = v_oversample; -} - -STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip) -{ - spc->skip_missing = skip; -} - -#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1) - -static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) -{ - unsigned char buffer[STBTT_MAX_OVERSAMPLE]; - int safe_w = w - kernel_width; - int j; - STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze - for (j=0; j < h; ++j) { - int i; - unsigned int total; - STBTT_memset(buffer, 0, kernel_width); - - total = 0; - - // make kernel_width a constant in common cases so compiler can optimize out the divide - switch (kernel_width) { - case 2: - for (i=0; i <= safe_w; ++i) { - total += pixels[i] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; - pixels[i] = (unsigned char) (total / 2); - } - break; - case 3: - for (i=0; i <= safe_w; ++i) { - total += pixels[i] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; - pixels[i] = (unsigned char) (total / 3); - } - break; - case 4: - for (i=0; i <= safe_w; ++i) { - total += pixels[i] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; - pixels[i] = (unsigned char) (total / 4); - } - break; - case 5: - for (i=0; i <= safe_w; ++i) { - total += pixels[i] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; - pixels[i] = (unsigned char) (total / 5); - } - break; - default: - for (i=0; i <= safe_w; ++i) { - total += pixels[i] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; - pixels[i] = (unsigned char) (total / kernel_width); - } - break; - } - - for (; i < w; ++i) { - STBTT_assert(pixels[i] == 0); - total -= buffer[i & STBTT__OVER_MASK]; - pixels[i] = (unsigned char) (total / kernel_width); - } - - pixels += stride_in_bytes; - } -} - -static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) -{ - unsigned char buffer[STBTT_MAX_OVERSAMPLE]; - int safe_h = h - kernel_width; - int j; - STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze - for (j=0; j < w; ++j) { - int i; - unsigned int total; - STBTT_memset(buffer, 0, kernel_width); - - total = 0; - - // make kernel_width a constant in common cases so compiler can optimize out the divide - switch (kernel_width) { - case 2: - for (i=0; i <= safe_h; ++i) { - total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; - pixels[i*stride_in_bytes] = (unsigned char) (total / 2); - } - break; - case 3: - for (i=0; i <= safe_h; ++i) { - total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; - pixels[i*stride_in_bytes] = (unsigned char) (total / 3); - } - break; - case 4: - for (i=0; i <= safe_h; ++i) { - total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; - pixels[i*stride_in_bytes] = (unsigned char) (total / 4); - } - break; - case 5: - for (i=0; i <= safe_h; ++i) { - total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; - pixels[i*stride_in_bytes] = (unsigned char) (total / 5); - } - break; - default: - for (i=0; i <= safe_h; ++i) { - total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; - buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; - pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); - } - break; - } - - for (; i < h; ++i) { - STBTT_assert(pixels[i*stride_in_bytes] == 0); - total -= buffer[i & STBTT__OVER_MASK]; - pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); - } - - pixels += 1; - } -} - -static float stbtt__oversample_shift(int oversample) -{ - if (!oversample) - return 0.0f; - - // The prefilter is a box filter of width "oversample", - // which shifts phase by (oversample - 1)/2 pixels in - // oversampled space. We want to shift in the opposite - // direction to counter this. - return (float)-(oversample - 1) / (2.0f * (float)oversample); -} - -// rects array must be big enough to accommodate all characters in the given ranges -STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) -{ - int i,j,k; - int missing_glyph_added = 0; - - k=0; - for (i=0; i < num_ranges; ++i) { - float fh = ranges[i].font_size; - float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); - ranges[i].h_oversample = (unsigned char) spc->h_oversample; - ranges[i].v_oversample = (unsigned char) spc->v_oversample; - for (j=0; j < ranges[i].num_chars; ++j) { - int x0,y0,x1,y1; - int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; - int glyph = stbtt_FindGlyphIndex(info, codepoint); - if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) { - rects[k].w = rects[k].h = 0; - } else { - stbtt_GetGlyphBitmapBoxSubpixel(info,glyph, - scale * spc->h_oversample, - scale * spc->v_oversample, - 0,0, - &x0,&y0,&x1,&y1); - rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1); - rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1); - if (glyph == 0) - missing_glyph_added = 1; - } - ++k; - } - } - - return k; -} - -STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph) -{ - stbtt_MakeGlyphBitmapSubpixel(info, - output, - out_w - (prefilter_x - 1), - out_h - (prefilter_y - 1), - out_stride, - scale_x, - scale_y, - shift_x, - shift_y, - glyph); - - if (prefilter_x > 1) - stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x); - - if (prefilter_y > 1) - stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y); - - *sub_x = stbtt__oversample_shift(prefilter_x); - *sub_y = stbtt__oversample_shift(prefilter_y); -} - -// rects array must be big enough to accommodate all characters in the given ranges -STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) -{ - int i,j,k, missing_glyph = -1, return_value = 1; - - // save current values - int old_h_over = spc->h_oversample; - int old_v_over = spc->v_oversample; - - k = 0; - for (i=0; i < num_ranges; ++i) { - float fh = ranges[i].font_size; - float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); - float recip_h,recip_v,sub_x,sub_y; - spc->h_oversample = ranges[i].h_oversample; - spc->v_oversample = ranges[i].v_oversample; - recip_h = 1.0f / spc->h_oversample; - recip_v = 1.0f / spc->v_oversample; - sub_x = stbtt__oversample_shift(spc->h_oversample); - sub_y = stbtt__oversample_shift(spc->v_oversample); - for (j=0; j < ranges[i].num_chars; ++j) { - stbrp_rect *r = &rects[k]; - if (r->was_packed && r->w != 0 && r->h != 0) { - stbtt_packedchar *bc = &ranges[i].chardata_for_range[j]; - int advance, lsb, x0,y0,x1,y1; - int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; - int glyph = stbtt_FindGlyphIndex(info, codepoint); - stbrp_coord pad = (stbrp_coord) spc->padding; - - // pad on left and top - r->x += pad; - r->y += pad; - r->w -= pad; - r->h -= pad; - stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb); - stbtt_GetGlyphBitmapBox(info, glyph, - scale * spc->h_oversample, - scale * spc->v_oversample, - &x0,&y0,&x1,&y1); - stbtt_MakeGlyphBitmapSubpixel(info, - spc->pixels + r->x + r->y*spc->stride_in_bytes, - r->w - spc->h_oversample+1, - r->h - spc->v_oversample+1, - spc->stride_in_bytes, - scale * spc->h_oversample, - scale * spc->v_oversample, - 0,0, - glyph); - - if (spc->h_oversample > 1) - stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, - r->w, r->h, spc->stride_in_bytes, - spc->h_oversample); - - if (spc->v_oversample > 1) - stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, - r->w, r->h, spc->stride_in_bytes, - spc->v_oversample); - - bc->x0 = (stbtt_int16) r->x; - bc->y0 = (stbtt_int16) r->y; - bc->x1 = (stbtt_int16) (r->x + r->w); - bc->y1 = (stbtt_int16) (r->y + r->h); - bc->xadvance = scale * advance; - bc->xoff = (float) x0 * recip_h + sub_x; - bc->yoff = (float) y0 * recip_v + sub_y; - bc->xoff2 = (x0 + r->w) * recip_h + sub_x; - bc->yoff2 = (y0 + r->h) * recip_v + sub_y; - - if (glyph == 0) - missing_glyph = j; - } else if (spc->skip_missing) { - return_value = 0; - } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { - ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; - } else { - return_value = 0; // if any fail, report failure - } - - ++k; - } - } - - // restore original values - spc->h_oversample = old_h_over; - spc->v_oversample = old_v_over; - - return return_value; -} - -STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects) -{ - stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects); -} - -STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) -{ - stbtt_fontinfo info; - int i,j,n, return_value = 1; - //stbrp_context *context = (stbrp_context *) spc->pack_info; - stbrp_rect *rects; - - // flag all characters as NOT packed - for (i=0; i < num_ranges; ++i) - for (j=0; j < ranges[i].num_chars; ++j) - ranges[i].chardata_for_range[j].x0 = - ranges[i].chardata_for_range[j].y0 = - ranges[i].chardata_for_range[j].x1 = - ranges[i].chardata_for_range[j].y1 = 0; - - n = 0; - for (i=0; i < num_ranges; ++i) - n += ranges[i].num_chars; - - rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context); - if (rects == NULL) - return 0; - - info.userdata = spc->user_allocator_context; - stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index)); - - n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects); - - stbtt_PackFontRangesPackRects(spc, rects, n); - - return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects); - - STBTT_free(rects, spc->user_allocator_context); - return return_value; -} - -STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, - int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) -{ - stbtt_pack_range range; - range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range; - range.array_of_unicode_codepoints = NULL; - range.num_chars = num_chars_in_range; - range.chardata_for_range = chardata_for_range; - range.font_size = font_size; - return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1); -} - -STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap) -{ - int i_ascent, i_descent, i_lineGap; - float scale; - stbtt_fontinfo info; - stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index)); - scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size); - stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap); - *ascent = (float) i_ascent * scale; - *descent = (float) i_descent * scale; - *lineGap = (float) i_lineGap * scale; -} - -STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer) -{ - float ipw = 1.0f / pw, iph = 1.0f / ph; - const stbtt_packedchar *b = chardata + char_index; - - if (align_to_integer) { - float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f); - float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f); - q->x0 = x; - q->y0 = y; - q->x1 = x + b->xoff2 - b->xoff; - q->y1 = y + b->yoff2 - b->yoff; - } else { - q->x0 = *xpos + b->xoff; - q->y0 = *ypos + b->yoff; - q->x1 = *xpos + b->xoff2; - q->y1 = *ypos + b->yoff2; - } - - q->s0 = b->x0 * ipw; - q->t0 = b->y0 * iph; - q->s1 = b->x1 * ipw; - q->t1 = b->y1 * iph; - - *xpos += b->xadvance; -} - -////////////////////////////////////////////////////////////////////////////// -// -// sdf computation -// - -#define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) -#define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) - -static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2]) -{ - float q0perp = q0[1]*ray[0] - q0[0]*ray[1]; - float q1perp = q1[1]*ray[0] - q1[0]*ray[1]; - float q2perp = q2[1]*ray[0] - q2[0]*ray[1]; - float roperp = orig[1]*ray[0] - orig[0]*ray[1]; - - float a = q0perp - 2*q1perp + q2perp; - float b = q1perp - q0perp; - float c = q0perp - roperp; - - float s0 = 0., s1 = 0.; - int num_s = 0; - - if (a != 0.0) { - float discr = b*b - a*c; - if (discr > 0.0) { - float rcpna = -1 / a; - float d = (float) STBTT_sqrt(discr); - s0 = (b+d) * rcpna; - s1 = (b-d) * rcpna; - if (s0 >= 0.0 && s0 <= 1.0) - num_s = 1; - if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) { - if (num_s == 0) s0 = s1; - ++num_s; - } - } - } else { - // 2*b*s + c = 0 - // s = -c / (2*b) - s0 = c / (-2 * b); - if (s0 >= 0.0 && s0 <= 1.0) - num_s = 1; - } - - if (num_s == 0) - return 0; - else { - float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); - float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; - - float q0d = q0[0]*rayn_x + q0[1]*rayn_y; - float q1d = q1[0]*rayn_x + q1[1]*rayn_y; - float q2d = q2[0]*rayn_x + q2[1]*rayn_y; - float rod = orig[0]*rayn_x + orig[1]*rayn_y; - - float q10d = q1d - q0d; - float q20d = q2d - q0d; - float q0rd = q0d - rod; - - hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d; - hits[0][1] = a*s0+b; - - if (num_s > 1) { - hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d; - hits[1][1] = a*s1+b; - return 2; - } else { - return 1; - } - } -} - -static int equal(float *a, float *b) -{ - return (a[0] == b[0] && a[1] == b[1]); -} - -static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts) -{ - int i; - float orig[2], ray[2] = { 1, 0 }; - float y_frac; - int winding = 0; - - // make sure y never passes through a vertex of the shape - y_frac = (float) STBTT_fmod(y, 1.0f); - if (y_frac < 0.01f) - y += 0.01f; - else if (y_frac > 0.99f) - y -= 0.01f; - - orig[0] = x; - orig[1] = y; - - // test a ray from (-infinity,y) to (x,y) - for (i=0; i < nverts; ++i) { - if (verts[i].type == STBTT_vline) { - int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; - int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y; - if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { - float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; - if (x_inter < x) - winding += (y0 < y1) ? 1 : -1; - } - } - if (verts[i].type == STBTT_vcurve) { - int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ; - int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy; - int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ; - int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2)); - int by = STBTT_max(y0,STBTT_max(y1,y2)); - if (y > ay && y < by && x > ax) { - float q0[2],q1[2],q2[2]; - float hits[2][2]; - q0[0] = (float)x0; - q0[1] = (float)y0; - q1[0] = (float)x1; - q1[1] = (float)y1; - q2[0] = (float)x2; - q2[1] = (float)y2; - if (equal(q0,q1) || equal(q1,q2)) { - x0 = (int)verts[i-1].x; - y0 = (int)verts[i-1].y; - x1 = (int)verts[i ].x; - y1 = (int)verts[i ].y; - if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { - float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; - if (x_inter < x) - winding += (y0 < y1) ? 1 : -1; - } - } else { - int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits); - if (num_hits >= 1) - if (hits[0][0] < 0) - winding += (hits[0][1] < 0 ? -1 : 1); - if (num_hits >= 2) - if (hits[1][0] < 0) - winding += (hits[1][1] < 0 ? -1 : 1); - } - } - } - } - return winding; -} - -static float stbtt__cuberoot( float x ) -{ - if (x<0) - return -(float) STBTT_pow(-x,1.0f/3.0f); - else - return (float) STBTT_pow( x,1.0f/3.0f); -} - -// x^3 + a*x^2 + b*x + c = 0 -static int stbtt__solve_cubic(float a, float b, float c, float* r) -{ - float s = -a / 3; - float p = b - a*a / 3; - float q = a * (2*a*a - 9*b) / 27 + c; - float p3 = p*p*p; - float d = q*q + 4*p3 / 27; - if (d >= 0) { - float z = (float) STBTT_sqrt(d); - float u = (-q + z) / 2; - float v = (-q - z) / 2; - u = stbtt__cuberoot(u); - v = stbtt__cuberoot(v); - r[0] = s + u + v; - return 1; - } else { - float u = (float) STBTT_sqrt(-p/3); - float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative - float m = (float) STBTT_cos(v); - float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f; - r[0] = s + u * 2 * m; - r[1] = s - u * (m + n); - r[2] = s - u * (m - n); - - //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? - //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); - //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); - return 3; - } -} - -STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) -{ - float scale_x = scale, scale_y = scale; - int ix0,iy0,ix1,iy1; - int w,h; - unsigned char *data; - - if (scale == 0) return NULL; - - stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); - - // if empty, return NULL - if (ix0 == ix1 || iy0 == iy1) - return NULL; - - ix0 -= padding; - iy0 -= padding; - ix1 += padding; - iy1 += padding; - - w = (ix1 - ix0); - h = (iy1 - iy0); - - if (width ) *width = w; - if (height) *height = h; - if (xoff ) *xoff = ix0; - if (yoff ) *yoff = iy0; - - // invert for y-downwards bitmaps - scale_y = -scale_y; - - { - // distance from singular values (in the same units as the pixel grid) - const float eps = 1./1024, eps2 = eps*eps; - int x,y,i,j; - float *precompute; - stbtt_vertex *verts; - int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); - data = (unsigned char *) STBTT_malloc(w * h, info->userdata); - precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata); - - for (i=0,j=num_verts-1; i < num_verts; j=i++) { - if (verts[i].type == STBTT_vline) { - float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; - float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; - float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0)); - precompute[i] = (dist < eps) ? 0.0f : 1.0f / dist; - } else if (verts[i].type == STBTT_vcurve) { - float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; - float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; - float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; - float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; - float len2 = bx*bx + by*by; - if (len2 >= eps2) - precompute[i] = 1.0f / len2; - else - precompute[i] = 0.0f; - } else - precompute[i] = 0.0f; - } - - for (y=iy0; y < iy1; ++y) { - for (x=ix0; x < ix1; ++x) { - float val; - float min_dist = 999999.0f; - float sx = (float) x + 0.5f; - float sy = (float) y + 0.5f; - float x_gspace = (sx / scale_x); - float y_gspace = (sy / scale_y); - - int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path - - for (i=0; i < num_verts; ++i) { - float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; - - if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) { - float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; - - float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); - if (dist2 < min_dist*min_dist) - min_dist = (float) STBTT_sqrt(dist2); - - // coarse culling against bbox - //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && - // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) - dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; - STBTT_assert(i != 0); - if (dist < min_dist) { - // check position along line - // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) - // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) - float dx = x1-x0, dy = y1-y0; - float px = x0-sx, py = y0-sy; - // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy - // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve - float t = -(px*dx + py*dy) / (dx*dx + dy*dy); - if (t >= 0.0f && t <= 1.0f) - min_dist = dist; - } - } else if (verts[i].type == STBTT_vcurve) { - float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; - float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; - float box_x0 = STBTT_min(STBTT_min(x0,x1),x2); - float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); - float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); - float box_y1 = STBTT_max(STBTT_max(y0,y1),y2); - // coarse culling against bbox to avoid computing cubic unnecessarily - if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { - int num=0; - float ax = x1-x0, ay = y1-y0; - float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; - float mx = x0 - sx, my = y0 - sy; - float res[3] = {0.f,0.f,0.f}; - float px,py,t,it,dist2; - float a_inv = precompute[i]; - if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula - float a = 3*(ax*bx + ay*by); - float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); - float c = mx*ax+my*ay; - if (STBTT_fabs(a) < eps2) { // if a is 0, it's linear - if (STBTT_fabs(b) >= eps2) { - res[num++] = -c/b; - } - } else { - float discriminant = b*b - 4*a*c; - if (discriminant < 0) - num = 0; - else { - float root = (float) STBTT_sqrt(discriminant); - res[0] = (-b - root)/(2*a); - res[1] = (-b + root)/(2*a); - num = 2; // don't bother distinguishing 1-solution case, as code below will still work - } - } - } else { - float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point - float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; - float d = (mx*ax+my*ay) * a_inv; - num = stbtt__solve_cubic(b, c, d, res); - } - dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); - if (dist2 < min_dist*min_dist) - min_dist = (float) STBTT_sqrt(dist2); - - if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) { - t = res[0], it = 1.0f - t; - px = it*it*x0 + 2*t*it*x1 + t*t*x2; - py = it*it*y0 + 2*t*it*y1 + t*t*y2; - dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); - if (dist2 < min_dist * min_dist) - min_dist = (float) STBTT_sqrt(dist2); - } - if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) { - t = res[1], it = 1.0f - t; - px = it*it*x0 + 2*t*it*x1 + t*t*x2; - py = it*it*y0 + 2*t*it*y1 + t*t*y2; - dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); - if (dist2 < min_dist * min_dist) - min_dist = (float) STBTT_sqrt(dist2); - } - if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) { - t = res[2], it = 1.0f - t; - px = it*it*x0 + 2*t*it*x1 + t*t*x2; - py = it*it*y0 + 2*t*it*y1 + t*t*y2; - dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); - if (dist2 < min_dist * min_dist) - min_dist = (float) STBTT_sqrt(dist2); - } - } - } - } - if (winding == 0) - min_dist = -min_dist; // if outside the shape, value is negative - val = onedge_value + pixel_dist_scale * min_dist; - if (val < 0) - val = 0; - else if (val > 255) - val = 255; - data[(y-iy0)*w+(x-ix0)] = (unsigned char) val; - } - } - STBTT_free(precompute, info->userdata); - STBTT_free(verts, info->userdata); - } - return data; -} - -STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) -{ - return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff); -} - -STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) -{ - STBTT_free(bitmap, userdata); -} - -////////////////////////////////////////////////////////////////////////////// -// -// font name matching -- recommended not to use this -// - -// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string -static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) -{ - stbtt_int32 i=0; - - // convert utf16 to utf8 and compare the results while converting - while (len2) { - stbtt_uint16 ch = s2[0]*256 + s2[1]; - if (ch < 0x80) { - if (i >= len1) return -1; - if (s1[i++] != ch) return -1; - } else if (ch < 0x800) { - if (i+1 >= len1) return -1; - if (s1[i++] != 0xc0 + (ch >> 6)) return -1; - if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; - } else if (ch >= 0xd800 && ch < 0xdc00) { - stbtt_uint32 c; - stbtt_uint16 ch2 = s2[2]*256 + s2[3]; - if (i+3 >= len1) return -1; - c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; - if (s1[i++] != 0xf0 + (c >> 18)) return -1; - if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; - if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; - if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; - s2 += 2; // plus another 2 below - len2 -= 2; - } else if (ch >= 0xdc00 && ch < 0xe000) { - return -1; - } else { - if (i+2 >= len1) return -1; - if (s1[i++] != 0xe0 + (ch >> 12)) return -1; - if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; - if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; - } - s2 += 2; - len2 -= 2; - } - return i; -} - -static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) -{ - return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); -} - -// returns results in whatever encoding you request... but note that 2-byte encodings -// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare -STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) -{ - stbtt_int32 i,count,stringOffset; - stbtt_uint8 *fc = font->data; - stbtt_uint32 offset = font->fontstart; - stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); - if (!nm) return NULL; - - count = ttUSHORT(fc+nm+2); - stringOffset = nm + ttUSHORT(fc+nm+4); - for (i=0; i < count; ++i) { - stbtt_uint32 loc = nm + 6 + 12 * i; - if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) - && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { - *length = ttUSHORT(fc+loc+8); - return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); - } - } - return NULL; -} - -static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) -{ - stbtt_int32 i; - stbtt_int32 count = ttUSHORT(fc+nm+2); - stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); - - for (i=0; i < count; ++i) { - stbtt_uint32 loc = nm + 6 + 12 * i; - stbtt_int32 id = ttUSHORT(fc+loc+6); - if (id == target_id) { - // find the encoding - stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); - - // is this a Unicode encoding? - if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { - stbtt_int32 slen = ttUSHORT(fc+loc+8); - stbtt_int32 off = ttUSHORT(fc+loc+10); - - // check if there's a prefix match - stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); - if (matchlen >= 0) { - // check for target_id+1 immediately following, with same encoding & language - if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { - slen = ttUSHORT(fc+loc+12+8); - off = ttUSHORT(fc+loc+12+10); - if (slen == 0) { - if (matchlen == nlen) - return 1; - } else if (matchlen < nlen && name[matchlen] == ' ') { - ++matchlen; - if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) - return 1; - } - } else { - // if nothing immediately following - if (matchlen == nlen) - return 1; - } - } - } - - // @TODO handle other encodings - } - } - return 0; -} - -static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) -{ - stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name); - stbtt_uint32 nm,hd; - if (!stbtt__isfont(fc+offset)) return 0; - - // check italics/bold/underline flags in macStyle... - if (flags) { - hd = stbtt__find_table(fc, offset, "head"); - if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; - } - - nm = stbtt__find_table(fc, offset, "name"); - if (!nm) return 0; - - if (flags) { - // if we checked the macStyle flags, then just check the family and ignore the subfamily - if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; - if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; - if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; - } else { - if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; - if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; - if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; - } - - return 0; -} - -static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags) -{ - stbtt_int32 i; - for (i=0;;++i) { - stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); - if (off < 0) return off; - if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) - return off; - } -} - -#if defined(__GNUC__) || defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wcast-qual" -#endif - -STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, - float pixel_height, unsigned char *pixels, int pw, int ph, - int first_char, int num_chars, stbtt_bakedchar *chardata) -{ - return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata); -} - -STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index) -{ - return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); -} - -STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) -{ - return stbtt_GetNumberOfFonts_internal((unsigned char *) data); -} - -STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) -{ - return stbtt_InitFont_internal(info, (unsigned char *) data, offset); -} - -STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) -{ - return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags); -} - -STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) -{ - return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2); -} - -#if defined(__GNUC__) || defined(__clang__) -#pragma GCC diagnostic pop -#endif - -#endif // STB_TRUETYPE_IMPLEMENTATION - - -// FULL VERSION HISTORY -// -// 1.25 (2021-07-11) many fixes -// 1.24 (2020-02-05) fix warning -// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) -// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined -// 1.21 (2019-02-25) fix warning -// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() -// 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod -// 1.18 (2018-01-29) add missing function -// 1.17 (2017-07-23) make more arguments const; doc fix -// 1.16 (2017-07-12) SDF support -// 1.15 (2017-03-03) make more arguments const -// 1.14 (2017-01-16) num-fonts-in-TTC function -// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts -// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual -// 1.11 (2016-04-02) fix unused-variable warning -// 1.10 (2016-04-02) allow user-defined fabs() replacement -// fix memory leak if fontsize=0.0 -// fix warning from duplicate typedef -// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges -// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges -// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; -// allow PackFontRanges to pack and render in separate phases; -// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); -// fixed an assert() bug in the new rasterizer -// replace assert() with STBTT_assert() in new rasterizer -// 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) -// also more precise AA rasterizer, except if shapes overlap -// remove need for STBTT_sort -// 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC -// 1.04 (2015-04-15) typo in example -// 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes -// 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ -// 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match -// non-oversampled; STBTT_POINT_SIZE for packed case only -// 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling -// 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) -// 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID -// 0.8b (2014-07-07) fix a warning -// 0.8 (2014-05-25) fix a few more warnings -// 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back -// 0.6c (2012-07-24) improve documentation -// 0.6b (2012-07-20) fix a few more warnings -// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, -// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty -// 0.5 (2011-12-09) bugfixes: -// subpixel glyph renderer computed wrong bounding box -// first vertex of shape can be off-curve (FreeSans) -// 0.4b (2011-12-03) fixed an error in the font baking example -// 0.4 (2011-12-01) kerning, subpixel rendering (tor) -// bugfixes for: -// codepoint-to-glyph conversion using table fmt=12 -// codepoint-to-glyph conversion using table fmt=4 -// stbtt_GetBakedQuad with non-square texture (Zer) -// updated Hello World! sample to use kerning and subpixel -// fixed some warnings -// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) -// userdata, malloc-from-userdata, non-zero fill (stb) -// 0.2 (2009-03-11) Fix unsigned/signed char warnings -// 0.1 (2009-03-09) First public release -// - -/* ------------------------------------------------------------------------------- -This software is available under 2 licenses -- choose whichever you prefer. ------------------------------------------------------------------------------- -ALTERNATIVE A - MIT License -Copyright (c) 2017 Sean Barrett -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. ------------------------------------------------------------------------------- -ALTERNATIVE B - Public Domain (www.unlicense.org) -This is free and unencumbered software released into the public domain. -Anyone is free to copy, modify, publish, use, compile, sell, or distribute this -software, either in source code form or as a compiled binary, for any purpose, -commercial or non-commercial, and by any means. -In jurisdictions that recognize copyright laws, the author or authors of this -software dedicate any and all copyright interest in the software to the public -domain. We make this dedication for the benefit of the public at large and to -the detriment of our heirs and successors. We intend this dedication to be an -overt act of relinquishment in perpetuity of all present and future rights to -this software under copyright law. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------- -*/ diff --git a/Extra2D/src/asset/asset_loader.cpp b/Extra2D/src/asset/asset_loader.cpp index 4bf24ad..60bedc5 100644 --- a/Extra2D/src/asset/asset_loader.cpp +++ b/Extra2D/src/asset/asset_loader.cpp @@ -124,42 +124,167 @@ void TextureLoader::setDesiredChannels(int channels) { } // --------------------------------------------------------------------------- -// FontLoader 实现 +// FontLoader 实现 (MSDF) // --------------------------------------------------------------------------- Ref FontLoader::load(const std::string &path) { - auto data = readFile(path); - if (data.empty()) { - E2D_ERROR(CAT_ASSET, "Failed to read font file: {}", path); - return nullptr; - } - return loadFromMemory(data.data(), data.size()); + auto asset = ptr::make(); + + if (!parseEmbeddedMetadata(path, asset.get())) { + E2D_ERROR(CAT_ASSET, "Failed to parse MSDF font metadata: {}", path); + return nullptr; + } + + asset->markLoaded(); + return asset; } Ref FontLoader::loadFromMemory(const u8 *data, size_t size) { - if (!data || size == 0) { + E2D_ERROR(CAT_ASSET, "MSDF font loading from memory not supported"); return nullptr; - } - - auto asset = ptr::make(); - - std::vector fontData(data, data + size); - if (!asset->setData(std::move(fontData))) { - E2D_ERROR(CAT_ASSET, "Failed to initialize font from memory"); - return nullptr; - } - - return asset; } bool FontLoader::canLoad(const std::string &path) const { - std::string ext = getExtension(path); - auto exts = extensions(); - return std::find(exts.begin(), exts.end(), ext) != exts.end(); + std::string ext = getExtension(path); + auto exts = extensions(); + return std::find(exts.begin(), exts.end(), ext) != exts.end(); } std::vector FontLoader::extensions() const { - return {".ttf", ".otf", ".ttc"}; + return {".msdf", ".png"}; +} + +bool FontLoader::parseEmbeddedMetadata(const std::string &path, FontAsset *asset) { + auto pngData = readFile(path); + if (pngData.empty()) { + E2D_ERROR(CAT_ASSET, "Failed to read MSDF font file: {}", path); + return false; + } + + std::vector metadataJson; + if (!readTextChunk(pngData, "msdf", metadataJson)) { + E2D_ERROR(CAT_ASSET, "Failed to read MSDF metadata chunk from: {}", path); + return false; + } + + std::string jsonStr(metadataJson.begin(), metadataJson.end()); + if (!parseJsonMetadata(jsonStr, asset)) { + E2D_ERROR(CAT_ASSET, "Failed to parse MSDF metadata JSON from: {}", path); + return false; + } + + int width, height, channels; + u8 *pixels = stbi_load_from_memory(pngData.data(), static_cast(pngData.size()), + &width, &height, &channels, 4); + if (!pixels) { + E2D_ERROR(CAT_ASSET, "Failed to decode MSDF texture from: {}", path); + return false; + } + + GLuint texture; + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, pixels); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + stbi_image_free(pixels); + + asset->setTextureId(texture); + asset->setAtlasSize(width, height); + + return true; +} + +bool FontLoader::readTextChunk(const std::vector &pngData, + const std::string &keyword, + std::vector &output) { + if (pngData.size() < 8) return false; + + if (pngData[0] != 0x89 || pngData[1] != 'P' || pngData[2] != 'N' || pngData[3] != 'G') { + return false; + } + + size_t pos = 8; + while (pos < pngData.size()) { + if (pos + 8 > pngData.size()) break; + + u32 length = (static_cast(pngData[pos]) << 24) | + (static_cast(pngData[pos + 1]) << 16) | + (static_cast(pngData[pos + 2]) << 8) | + static_cast(pngData[pos + 3]); + + std::string chunkType(pngData.begin() + pos + 4, pngData.begin() + pos + 8); + + if (chunkType == "tEXt") { + size_t dataStart = pos + 8; + size_t nullPos = dataStart; + while (nullPos < pngData.size() && pngData[nullPos] != 0) { + nullPos++; + } + + std::string foundKeyword(pngData.begin() + dataStart, pngData.begin() + nullPos); + if (foundKeyword == keyword) { + output.assign(pngData.begin() + nullPos + 1, pngData.begin() + pos + 8 + length); + return true; + } + } + + pos += 12 + length; + } + + return false; +} + +bool FontLoader::parseJsonMetadata(const std::string &json, FontAsset *asset) { + try { + auto j = nlohmann::json::parse(json); + + asset->setFontSize(j.value("size", 48)); + asset->setPxRange(j.value("pxRange", 4.0f)); + asset->setLineHeight(j.value("lineHeight", 60)); + asset->setBaseline(j.value("baseline", 12)); + + if (j.contains("atlas")) { + auto atlas = j["atlas"]; + asset->setAtlasSize(atlas.value("width", 2048), atlas.value("height", 2048)); + } + + if (j.contains("glyphs")) { + for (const auto &glyphJson : j["glyphs"]) { + GlyphInfo glyph; + glyph.codepoint = glyphJson.value("unicode", 0u); + + if (glyphJson.contains("atlasBounds")) { + auto bounds = glyphJson["atlasBounds"]; + glyph.uvMin.x = bounds.value("left", 0.0f) / asset->atlasWidth(); + glyph.uvMin.y = bounds.value("top", 0.0f) / asset->atlasHeight(); + glyph.uvMax.x = bounds.value("right", 0.0f) / asset->atlasWidth(); + glyph.uvMax.y = bounds.value("bottom", 0.0f) / asset->atlasHeight(); + } + + if (glyphJson.contains("planeBounds")) { + auto plane = glyphJson["planeBounds"]; + glyph.size.x = plane.value("right", 0.0f) - plane.value("left", 0.0f); + glyph.size.y = plane.value("top", 0.0f) - plane.value("bottom", 0.0f); + glyph.bearing.x = plane.value("left", 0.0f); + glyph.bearing.y = plane.value("top", 0.0f); + } + + glyph.advance = glyphJson.value("advance", 0.0f); + + asset->addGlyph(glyph); + } + } + + return true; + } catch (const std::exception &e) { + E2D_ERROR(CAT_ASSET, "Failed to parse MSDF metadata: {}", e.what()); + return false; + } } // --------------------------------------------------------------------------- @@ -640,11 +765,11 @@ AssetType AssetLoaderFactory::getTypeByExtension(const std::string &extension) { return AssetType::Texture; } - if (ext == ".ttf" || ext == ".otf" || ext == ".ttc") { + if (ext == ".msdf" || ext == ".font.png") { return AssetType::Font; } - if (ext == ".vert" || ext == ".frag" || ext == ".glsl" || ext == ".vs" || + if (ext == ".json" || ext == ".vert" || ext == ".frag" || ext == ".glsl" || ext == ".vs" || ext == ".fs") { return AssetType::Shader; } diff --git a/Extra2D/src/asset/font_asset.cpp b/Extra2D/src/asset/font_asset.cpp index dad5611..6cf2f32 100644 --- a/Extra2D/src/asset/font_asset.cpp +++ b/Extra2D/src/asset/font_asset.cpp @@ -1,54 +1,86 @@ #include -#define STB_TRUETYPE_IMPLEMENTATION -#include - namespace extra2d { -class FontAsset::Impl { -public: - stbtt_fontinfo info; - bool initialized = false; -}; +FontAsset::FontAsset() = default; -FontAsset::FontAsset() : impl_(ptr::unique()) {} - -FontAsset::~FontAsset() = default; +FontAsset::~FontAsset() { + release(); +} bool FontAsset::loaded() const { return state_.load(std::memory_order_acquire) == AssetState::Loaded && - impl_->initialized; + textureId_ != 0; } -float FontAsset::scaleForPixelHeight(float pixels) const { - if (!impl_->initialized || data_.empty()) { - return 0.0f; - } - return stbtt_ScaleForPixelHeight(&impl_->info, pixels); +size_t FontAsset::memSize() const { + return glyphs_.size() * sizeof(GlyphInfo); } -bool FontAsset::setData(std::vector data) { - if (data.empty()) { - return false; +const GlyphInfo* FontAsset::getGlyph(char32_t codepoint) const { + auto it = glyphs_.find(codepoint); + if (it != glyphs_.end()) { + return &it->second; } + return nullptr; +} - data_ = std::move(data); +bool FontAsset::hasGlyph(char32_t codepoint) const { + return glyphs_.find(codepoint) != glyphs_.end(); +} - if (!stbtt_InitFont(&impl_->info, data_.data(), 0)) { - data_.clear(); - impl_->initialized = false; - setState(AssetState::Failed); - return false; +std::vector FontAsset::getMissingChars(const std::u32string& text) const { + std::vector missing; + for (char32_t c : text) { + if (!hasGlyph(c)) { + missing.push_back(c); + } } + return missing; +} - impl_->initialized = true; - setState(AssetState::Loaded); +bool FontAsset::canRender(const std::u32string& text) const { + for (char32_t c : text) { + if (!hasGlyph(c)) { + return false; + } + } return true; } +glm::vec2 FontAsset::measureText(const std::u32string& text, float scale) const { + if (text.empty()) return glm::vec2(0.0f); + + float width = 0.0f; + float maxAscent = 0.0f; + float maxDescent = 0.0f; + + for (char32_t c : text) { + const GlyphInfo* glyph = getGlyph(c); + if (glyph) { + width += glyph->advance * scale; + maxAscent = glm::max(maxAscent, glyph->bearing.y * scale); + maxDescent = glm::max(maxDescent, (glyph->size.y - glyph->bearing.y) * scale); + } + } + + return glm::vec2(width, maxAscent + maxDescent); +} + +void FontAsset::addGlyph(const GlyphInfo& glyph) { + glyphs_[glyph.codepoint] = glyph; +} + +void FontAsset::markLoaded() { + setState(AssetState::Loaded); +} + void FontAsset::release() { - data_.clear(); - impl_->initialized = false; + if (textureId_ != 0) { + glDeleteTextures(1, &textureId_); + textureId_ = 0; + } + glyphs_.clear(); setState(AssetState::Unloaded); } diff --git a/Extra2D/src/asset/msdf_font_asset.cpp b/Extra2D/src/asset/msdf_font_asset.cpp deleted file mode 100644 index 4576abd..0000000 --- a/Extra2D/src/asset/msdf_font_asset.cpp +++ /dev/null @@ -1,87 +0,0 @@ -#include - -namespace extra2d { - -MSDFFontAsset::MSDFFontAsset() = default; - -MSDFFontAsset::~MSDFFontAsset() { - release(); -} - -bool MSDFFontAsset::loaded() const { - return state_.load(std::memory_order_acquire) == AssetState::Loaded && - textureId_ != 0; -} - -size_t MSDFFontAsset::memSize() const { - return glyphs_.size() * sizeof(GlyphInfo); -} - -const GlyphInfo* MSDFFontAsset::getGlyph(char32_t codepoint) const { - auto it = glyphs_.find(codepoint); - if (it != glyphs_.end()) { - return &it->second; - } - return nullptr; -} - -bool MSDFFontAsset::hasGlyph(char32_t codepoint) const { - return glyphs_.find(codepoint) != glyphs_.end(); -} - -std::vector MSDFFontAsset::getMissingChars(const std::u32string& text) const { - std::vector missing; - for (char32_t c : text) { - if (!hasGlyph(c)) { - missing.push_back(c); - } - } - return missing; -} - -bool MSDFFontAsset::canRender(const std::u32string& text) const { - for (char32_t c : text) { - if (!hasGlyph(c)) { - return false; - } - } - return true; -} - -glm::vec2 MSDFFontAsset::measureText(const std::u32string& text, float scale) const { - if (text.empty()) return glm::vec2(0.0f); - - float width = 0.0f; - float maxAscent = 0.0f; - float maxDescent = 0.0f; - - for (char32_t c : text) { - const GlyphInfo* glyph = getGlyph(c); - if (glyph) { - width += glyph->advance * scale; - maxAscent = glm::max(maxAscent, glyph->bearing.y * scale); - maxDescent = glm::max(maxDescent, (glyph->size.y - glyph->bearing.y) * scale); - } - } - - return glm::vec2(width, maxAscent + maxDescent); -} - -void MSDFFontAsset::addGlyph(const GlyphInfo& glyph) { - glyphs_[glyph.codepoint] = glyph; -} - -void MSDFFontAsset::markLoaded() { - setState(AssetState::Loaded); -} - -void MSDFFontAsset::release() { - if (textureId_ != 0) { - glDeleteTextures(1, &textureId_); - textureId_ = 0; - } - glyphs_.clear(); - setState(AssetState::Unloaded); -} - -} // namespace extra2d diff --git a/Extra2D/src/asset/msdf_font_loader.cpp b/Extra2D/src/asset/msdf_font_loader.cpp deleted file mode 100644 index fc5ee4e..0000000 --- a/Extra2D/src/asset/msdf_font_loader.cpp +++ /dev/null @@ -1,183 +0,0 @@ -#include -#include -#include -#include -#include - -namespace extra2d { - -namespace { - -std::vector readFile(const std::string& path) { - std::ifstream file(path, std::ios::binary | std::ios::ate); - if (!file) { - return {}; - } - - size_t size = static_cast(file.tellg()); - file.seekg(0, std::ios::beg); - - std::vector data(size); - if (!file.read(reinterpret_cast(data.data()), size)) { - return {}; - } - - return data; -} - -std::string getExtension(const std::string& path) { - size_t pos = path.rfind('.'); - if (pos == std::string::npos) { - return ""; - } - std::string ext = path.substr(pos); - std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower); - return ext; -} - -} - -Ref MSDFFontLoader::load(const std::string& path) { - auto asset = ptr::make(); - - if (!parseEmbeddedMetadata(path, asset.get())) { - E2D_ERROR(CAT_ASSET, "Failed to parse MSDF font metadata: {}", path); - return nullptr; - } - - asset->markLoaded(); - return asset; -} - -Ref MSDFFontLoader::loadFromMemory(const u8* data, size_t size) { - E2D_ERROR(CAT_ASSET, "MSDF font loading from memory not supported"); - return nullptr; -} - -bool MSDFFontLoader::canLoad(const std::string& path) const { - std::string ext = getExtension(path); - return ext == ".msdf" || ext == ".png"; -} - -std::vector MSDFFontLoader::extensions() const { - return {".msdf", ".png"}; -} - -bool MSDFFontLoader::parseEmbeddedMetadata(const std::string& path, MSDFFontAsset* asset) { - auto pngData = readFile(path); - if (pngData.empty()) { - return false; - } - - std::vector metadataJson; - if (!readTextChunk(pngData, "msdf", metadataJson)) { - return false; - } - - std::string jsonStr(metadataJson.begin(), metadataJson.end()); - if (!parseJsonMetadata(jsonStr, asset)) { - return false; - } - - GLuint texture; - glGenTextures(1, &texture); - glBindTexture(GL_TEXTURE_2D, texture); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - - asset->setTextureId(texture); - - return true; -} - -bool MSDFFontLoader::readTextChunk(const std::vector& pngData, - const std::string& keyword, - std::vector& output) { - if (pngData.size() < 8) return false; - - if (pngData[0] != 0x89 || pngData[1] != 'P' || pngData[2] != 'N' || pngData[3] != 'G') { - return false; - } - - size_t pos = 8; - while (pos < pngData.size()) { - if (pos + 8 > pngData.size()) break; - - u32 length = (static_cast(pngData[pos]) << 24) | - (static_cast(pngData[pos + 1]) << 16) | - (static_cast(pngData[pos + 2]) << 8) | - static_cast(pngData[pos + 3]); - - std::string chunkType(pngData.begin() + pos + 4, pngData.begin() + pos + 8); - - if (chunkType == "tEXt") { - size_t dataStart = pos + 8; - size_t nullPos = dataStart; - while (nullPos < pngData.size() && pngData[nullPos] != 0) { - nullPos++; - } - - std::string foundKeyword(pngData.begin() + dataStart, pngData.begin() + nullPos); - if (foundKeyword == keyword) { - output.assign(pngData.begin() + nullPos + 1, pngData.begin() + pos + 8 + length); - return true; - } - } - - pos += 12 + length; - } - - return false; -} - -bool MSDFFontLoader::parseJsonMetadata(const std::string& json, MSDFFontAsset* asset) { - try { - auto j = nlohmann::json::parse(json); - - asset->setFontSize(j.value("size", 48)); - asset->setPxRange(j.value("pxRange", 4.0f)); - asset->setLineHeight(j.value("lineHeight", 60)); - asset->setBaseline(j.value("baseline", 12)); - - if (j.contains("atlas")) { - auto atlas = j["atlas"]; - asset->setAtlasSize(atlas.value("width", 2048), atlas.value("height", 2048)); - } - - if (j.contains("glyphs")) { - for (const auto& glyphJson : j["glyphs"]) { - GlyphInfo glyph; - glyph.codepoint = glyphJson.value("unicode", 0u); - - if (glyphJson.contains("atlasBounds")) { - auto bounds = glyphJson["atlasBounds"]; - glyph.uvMin.x = bounds.value("left", 0.0f) / asset->atlasWidth(); - glyph.uvMin.y = bounds.value("top", 0.0f) / asset->atlasHeight(); - glyph.uvMax.x = bounds.value("right", 0.0f) / asset->atlasWidth(); - glyph.uvMax.y = bounds.value("bottom", 0.0f) / asset->atlasHeight(); - } - - if (glyphJson.contains("planeBounds")) { - auto plane = glyphJson["planeBounds"]; - glyph.size.x = plane.value("right", 0.0f) - plane.value("left", 0.0f); - glyph.size.y = plane.value("top", 0.0f) - plane.value("bottom", 0.0f); - glyph.bearing.x = plane.value("left", 0.0f); - glyph.bearing.y = plane.value("top", 0.0f); - } - - glyph.advance = glyphJson.value("advance", 0.0f); - - asset->addGlyph(glyph); - } - } - - return true; - } catch (const std::exception& e) { - E2D_ERROR(CAT_ASSET, "Failed to parse MSDF metadata: {}", e.what()); - return false; - } -} - -} // namespace extra2d diff --git a/Extra2D/src/render/msdf_text_renderer.cpp b/Extra2D/src/render/msdf_text_renderer.cpp deleted file mode 100644 index 5a476fe..0000000 --- a/Extra2D/src/render/msdf_text_renderer.cpp +++ /dev/null @@ -1,217 +0,0 @@ -#include -#include -#include - -namespace extra2d { - -static const char* MSDF_VERTEX_SHADER = R"( -#version 450 core -layout(location = 0) in vec2 a_position; -layout(location = 1) in vec2 a_texCoord; - -uniform mat4 u_projection; - -out vec2 v_texCoord; - -void main() { - gl_Position = u_projection * vec4(a_position, 0.0, 1.0); - v_texCoord = a_texCoord; -} -)"; - -static const char* MSDF_FRAGMENT_SHADER = R"( -#version 450 core -in vec2 v_texCoord; - -uniform sampler2D u_texture; -uniform float u_pxRange; -uniform vec4 u_color; - -out vec4 fragColor; - -float median(float r, float g, float b) { - return max(min(r, g), min(max(r, g), b)); -} - -void main() { - vec3 msdf = texture(u_texture, v_texCoord).rgb; - float sigDist = median(msdf.r, msdf.g, msdf.b); - - float pxRange = u_pxRange; - float alpha = smoothstep(0.5 - 0.5/pxRange, 0.5 + 0.5/pxRange, sigDist); - - fragColor = u_color * vec4(1.0, 1.0, 1.0, alpha); -} -)"; - -MSDFTextRenderer::MSDFTextRenderer() = default; - -MSDFTextRenderer::~MSDFTextRenderer() { - shutdown(); -} - -bool MSDFTextRenderer::init() { - return createShader(); -} - -void MSDFTextRenderer::shutdown() { - if (shader_) { - glDeleteProgram(shader_); - shader_ = 0; - } - if (vao_) { - glDeleteVertexArrays(1, &vao_); - vao_ = 0; - } - if (vbo_) { - glDeleteBuffers(1, &vbo_); - vbo_ = 0; - } - if (ibo_) { - glDeleteBuffers(1, &ibo_); - ibo_ = 0; - } -} - -void MSDFTextRenderer::setText(const std::string& utf8Text) { - size_t len = simdutf::utf32_length_from_utf8(utf8Text.data(), utf8Text.size()); - text_.resize(len); - simdutf::convert_utf8_to_utf32(utf8Text.data(), utf8Text.size(), text_.data()); -} - -void MSDFTextRenderer::setFontSize(float size) { - fontSize_ = size; - if (font_) { - scale_ = size / static_cast(font_->fontSize()); - } -} - -glm::vec2 MSDFTextRenderer::getSize() const { - if (font_) { - return font_->measureText(text_, scale_); - } - return glm::vec2(0.0f); -} - -void MSDFTextRenderer::render(const glm::mat4& projection) { - if (!font_ || text_.empty()) return; - - updateGeometry(); - - glUseProgram(shader_); - - GLint projLoc = glGetUniformLocation(shader_, "u_projection"); - glUniformMatrix4fv(projLoc, 1, GL_FALSE, &projection[0][0]); - - GLint texLoc = glGetUniformLocation(shader_, "u_texture"); - glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_2D, font_->textureId()); - glUniform1i(texLoc, 0); - - GLint pxRangeLoc = glGetUniformLocation(shader_, "u_pxRange"); - glUniform1f(pxRangeLoc, font_->pxRange() * scale_); - - GLint colorLoc = glGetUniformLocation(shader_, "u_color"); - glUniform4f(colorLoc, color_.r, color_.g, color_.b, color_.a); - - draw(); -} - -void MSDFTextRenderer::updateGeometry() { - vertices_.clear(); - indices_.clear(); - - float x = position_.x; - float y = position_.y; - - for (char32_t c : text_) { - const GlyphInfo* glyph = font_->getGlyph(c); - if (!glyph) continue; - - float x0 = x + glyph->bearing.x * scale_; - float y0 = y - glyph->bearing.y * scale_; - float x1 = x0 + glyph->size.x * scale_; - float y1 = y0 + glyph->size.y * scale_; - - uint32_t base = static_cast(vertices_.size()); - - vertices_.push_back({{x0, y0}, {glyph->uvMin.x, glyph->uvMin.y}}); - vertices_.push_back({{x1, y0}, {glyph->uvMax.x, glyph->uvMin.y}}); - vertices_.push_back({{x1, y1}, {glyph->uvMax.x, glyph->uvMax.y}}); - vertices_.push_back({{x0, y1}, {glyph->uvMin.x, glyph->uvMax.y}}); - - indices_.push_back(base + 0); - indices_.push_back(base + 1); - indices_.push_back(base + 2); - indices_.push_back(base + 0); - indices_.push_back(base + 2); - indices_.push_back(base + 3); - - x += glyph->advance * scale_; - } -} - -void MSDFTextRenderer::draw() { - if (vertices_.empty()) return; - - if (!vao_) { - glGenVertexArrays(1, &vao_); - glGenBuffers(1, &vbo_); - glGenBuffers(1, &ibo_); - } - - glBindVertexArray(vao_); - - glBindBuffer(GL_ARRAY_BUFFER, vbo_); - glBufferData(GL_ARRAY_BUFFER, vertices_.size() * sizeof(Vertex), vertices_.data(), GL_DYNAMIC_DRAW); - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_); - glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_.size() * sizeof(uint32_t), indices_.data(), GL_DYNAMIC_DRAW); - - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, position)); - - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texCoord)); - - glDrawElements(GL_TRIANGLES, static_cast(indices_.size()), GL_UNSIGNED_INT, nullptr); - - glBindVertexArray(0); -} - -bool MSDFTextRenderer::createShader() { - GLuint vs = glCreateShader(GL_VERTEX_SHADER); - glShaderSource(vs, 1, &MSDF_VERTEX_SHADER, nullptr); - glCompileShader(vs); - - GLint success; - glGetShaderiv(vs, GL_COMPILE_STATUS, &success); - if (!success) { - glDeleteShader(vs); - return false; - } - - GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); - glShaderSource(fs, 1, &MSDF_FRAGMENT_SHADER, nullptr); - glCompileShader(fs); - - glGetShaderiv(fs, GL_COMPILE_STATUS, &success); - if (!success) { - glDeleteShader(vs); - glDeleteShader(fs); - return false; - } - - shader_ = glCreateProgram(); - glAttachShader(shader_, vs); - glAttachShader(shader_, fs); - glLinkProgram(shader_); - - glGetProgramiv(shader_, GL_LINK_STATUS, &success); - glDeleteShader(vs); - glDeleteShader(fs); - - return success == GL_TRUE; -} - -} // namespace extra2d diff --git a/Extra2D/src/render/text_renderer.cpp b/Extra2D/src/render/text_renderer.cpp index 6223dbb..db10598 100644 --- a/Extra2D/src/render/text_renderer.cpp +++ b/Extra2D/src/render/text_renderer.cpp @@ -52,48 +52,6 @@ void main() { } )"; -FontAtlas::FontAtlas() = default; - -FontAtlas::~FontAtlas() { destroy(); } - -bool FontAtlas::create(int atlasWidth, int atlasHeight) { - width_ = atlasWidth; - height_ = atlasHeight; - - glCreateTextures(GL_TEXTURE_2D, 1, &texture_); - if (texture_ == 0) - return false; - - glTextureStorage2D(texture_, 1, GL_RGBA8, width_, height_); - glTextureParameteri(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTextureParameteri(texture_, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTextureParameteri(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTextureParameteri(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - - return true; -} - -void FontAtlas::destroy() { - if (texture_ != 0) { - glDeleteTextures(1, &texture_); - texture_ = 0; - } - glyphs_.clear(); -} - -void FontAtlas::addGlyph(char32_t codepoint, const GlyphInfo &info) { - glyphs_[codepoint] = info; -} - -const GlyphInfo *FontAtlas::getGlyph(char32_t codepoint) const { - auto it = glyphs_.find(codepoint); - return it != glyphs_.end() ? &it->second : nullptr; -} - -bool FontAtlas::hasGlyph(char32_t codepoint) const { - return glyphs_.find(codepoint) != glyphs_.end(); -} - TextRenderer::TextRenderer() { vertices_.resize(MAX_VERTICES); } TextRenderer::~TextRenderer() { shutdown(); } @@ -141,9 +99,9 @@ void TextRenderer::begin(const glm::mat4 &viewProjection) { drawCalls_ = 0; } -void TextRenderer::drawText(FontAtlas *font, const String32 &text, float x, +void TextRenderer::drawText(FontAsset *font, const String32 &text, float x, float y, const TextConfig &config) { - if (!font || !font->isValid() || text.empty()) + if (!font || !font->loaded() || text.empty()) return; if (font != currentFont_ || @@ -152,7 +110,7 @@ void TextRenderer::drawText(FontAtlas *font, const String32 &text, float x, currentFont_ = font; } - float scale = config.fontSize / 48.0f; + float scale = config.fontSize / static_cast(font->fontSize()); float cursorX = x; float cursorY = y; @@ -173,12 +131,12 @@ void TextRenderer::drawText(FontAtlas *font, const String32 &text, float x, } } -glm::vec2 TextRenderer::measureText(FontAtlas *font, const String32 &text, +glm::vec2 TextRenderer::measureText(FontAsset *font, const String32 &text, float fontSize) { if (!font || text.empty()) return glm::vec2(0.0f); - float scale = fontSize / 48.0f; + float scale = fontSize / static_cast(font->fontSize()); float width = 0.0f; float maxWidth = 0.0f; float height = fontSize; @@ -255,12 +213,12 @@ void TextRenderer::flush() { glUniform1i(texLoc, 0); GLint pxRangeLoc = glGetUniformLocation(shader_, "u_pxRange"); - glUniform1f(pxRangeLoc, 4.0f); + glUniform1f(pxRangeLoc, currentFont_->pxRange()); - glBindTextureUnit(0, currentFont_->texture()); + glBindTextureUnit(0, currentFont_->textureId()); vao_->bind(); - glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast(vertexCount_)); + glDrawArrays(GL_TRIANGLES, 0, static_cast(vertexCount_)); E2D_RENDER_STATS().addDrawCall(static_cast(vertexCount_), static_cast(vertexCount_ / 3)); @@ -294,17 +252,29 @@ void TextRenderer::addChar(const GlyphInfo &glyph, float x, float y, v.v = glyph.uvMin.y; vertices_[vertexCount_++] = v; - v.x = x0; + v.x = x1; v.y = y1; - v.u = glyph.uvMin.x; + v.u = glyph.uvMax.x; v.v = glyph.uvMax.y; vertices_[vertexCount_++] = v; + v.x = x0; + v.y = y0; + v.u = glyph.uvMin.x; + v.v = glyph.uvMin.y; + vertices_[vertexCount_++] = v; + v.x = x1; v.y = y1; v.u = glyph.uvMax.x; v.v = glyph.uvMax.y; vertices_[vertexCount_++] = v; + + v.x = x0; + v.y = y1; + v.u = glyph.uvMin.x; + v.v = glyph.uvMax.y; + vertices_[vertexCount_++] = v; } } // namespace extra2d diff --git a/Extra2D/src/render/vao.cpp b/Extra2D/src/render/vao.cpp index f275aed..b25788e 100644 --- a/Extra2D/src/render/vao.cpp +++ b/Extra2D/src/render/vao.cpp @@ -54,7 +54,7 @@ void VAO::setFormat(const VertexFormatDesc& format) { for (const auto& attr : format.attributes) { setAttribFormat(attr.location, attr.type, attr.offset, attr.normalized); - setAttribBinding(attr.location, attr.location); + setAttribBinding(attr.location, 0); enableAttrib(attr.location); } } diff --git a/Extra2D/src/services/asset_service.cpp b/Extra2D/src/services/asset_service.cpp index a6b1d8e..2c63a1f 100644 --- a/Extra2D/src/services/asset_service.cpp +++ b/Extra2D/src/services/asset_service.cpp @@ -17,6 +17,10 @@ bool AssetService::init() { return true; } + info_.name = "AssetService"; + info_.priority = ServicePriority::Resource; + info_.enabled = true; + setState(ServiceState::Initializing); registerLoader(AssetLoaderFactory::createTextureLoader()); diff --git a/Extra2D/src/services/render_service.cpp b/Extra2D/src/services/render_service.cpp new file mode 100644 index 0000000..226c7fb --- /dev/null +++ b/Extra2D/src/services/render_service.cpp @@ -0,0 +1,287 @@ +#include +#include +#include +#include + +namespace extra2d { + +RenderService::RenderService() { + info_.name = "RenderService"; + info_.priority = ServicePriority::Resource; + info_.enabled = true; +} + +RenderService::~RenderService() = default; + +bool RenderService::init() { + E2D_INFO(CAT_RENDER, "初始化渲染服务..."); + + renderer_ = std::make_unique(); + if (!renderer_->init()) { + E2D_ERROR(CAT_RENDER, "渲染器初始化失败"); + return false; + } + + textRenderer_ = std::make_unique(); + if (!textRenderer_->init()) { + E2D_ERROR(CAT_RENDER, "文本渲染器初始化失败"); + renderer_->shutdown(); + return false; + } + + setState(ServiceState::Running); + E2D_INFO(CAT_RENDER, "渲染服务初始化完成"); + return true; +} + +void RenderService::shutdown() { + E2D_INFO(CAT_RENDER, "关闭渲染服务..."); + + if (textRenderer_) { + textRenderer_->shutdown(); + textRenderer_.reset(); + } + + if (renderer_) { + renderer_->shutdown(); + renderer_.reset(); + } + + setState(ServiceState::Stopped); + E2D_INFO(CAT_RENDER, "渲染服务已关闭"); +} + +void RenderService::beginFrame(const Color &clearColor) { + if (renderer_) { + renderer_->beginFrame(clearColor); + } + inFrame_ = true; + + auto now = std::chrono::high_resolution_clock::now(); + frameStartTime_ = static_cast( + std::chrono::duration(now.time_since_epoch()).count()); +} + +void RenderService::endFrame() { + if (!inFrame_) { + return; + } + + if (textRenderer_) { + textRenderer_->end(); + } + + if (renderer_) { + renderer_->endFrame(); + } + + inFrame_ = false; + + auto now = std::chrono::high_resolution_clock::now(); + f32 frameEndTime = static_cast( + std::chrono::duration(now.time_since_epoch()).count()); + stats_.frameTime = frameEndTime - frameStartTime_; + + stats_.frameCount++; + fpsFrameCount_++; + fpsAccumulator_ += stats_.frameTime; + + if (fpsAccumulator_ >= 1.0f) { + stats_.fps = static_cast(fpsFrameCount_) / fpsAccumulator_; + fpsFrameCount_ = 0; + fpsAccumulator_ = 0.0f; + } +} + +void RenderService::setViewProjection(const glm::mat4 &viewProjection) { + if (renderer_) { + renderer_->setViewProjection(viewProjection); + } + if (textRenderer_) { + textRenderer_->begin(viewProjection); + } +} + +glm::mat4 RenderService::viewProjection() const { + if (renderer_) { + return renderer_->viewProjection(); + } + return glm::mat4(1.0f); +} + +void RenderService::setCamera(const Camera &camera) { + setViewProjection(camera.viewProjectionMatrix()); +} + +void RenderService::drawLine(const Vec2 &start, const Vec2 &end, + const Color &color, float width) { + if (renderer_) { + renderer_->drawLine(start, end, color, width); + } +} + +void RenderService::drawRect(const Rect &rect, const Color &color, + float width) { + if (renderer_) { + renderer_->drawRect(rect, color, width); + } +} + +void RenderService::fillRect(const Rect &rect, const Color &color) { + if (renderer_) { + renderer_->fillRect(rect, color); + } +} + +void RenderService::drawCircle(const Vec2 ¢er, float radius, + const Color &color, int segments, float width) { + if (renderer_) { + renderer_->drawCircle(center, radius, color, segments, width); + } +} + +void RenderService::fillCircle(const Vec2 ¢er, float radius, + const Color &color, int segments) { + if (renderer_) { + renderer_->fillCircle(center, radius, color, segments); + } +} + +void RenderService::drawTriangle(const Vec2 &p1, const Vec2 &p2, + const Vec2 &p3, const Color &color, + float width) { + if (renderer_) { + renderer_->drawTriangle(p1, p2, p3, color, width); + } +} + +void RenderService::fillTriangle(const Vec2 &p1, const Vec2 &p2, + const Vec2 &p3, const Color &color) { + if (renderer_) { + renderer_->fillTriangle(p1, p2, p3, color); + } +} + +void RenderService::drawPolygon(const std::vector &points, + const Color &color, float width) { + if (renderer_) { + renderer_->drawPolygon(points, color, width); + } +} + +void RenderService::fillPolygon(const std::vector &points, + const Color &color) { + if (renderer_) { + renderer_->fillPolygon(points, color); + } +} + +void RenderService::drawSprite(const Texture &texture, const Rect &destRect, + const Rect &srcRect, const Color &color, + float rotation, const Vec2 &anchor) { + if (renderer_) { + renderer_->drawSprite(texture, destRect, srcRect, color, rotation, anchor); + } +} + +void RenderService::drawSprite(const Texture &texture, const Vec2 &position, + const Color &color) { + if (renderer_) { + renderer_->drawSprite(texture, position, color); + } +} + +void RenderService::drawSprite(const Texture &texture, const Vec2 &position, + const Vec2 &scale, const Color &color) { + if (renderer_) { + renderer_->drawSprite(texture, position, scale, color); + } +} + +void RenderService::drawText(FontAsset *font, const String32 &text, float x, + float y, const TextConfig &config) { + if (textRenderer_ && font) { + ::extra2d::TextConfig cfg; + cfg.fontSize = config.fontSize; + cfg.color = config.color; + cfg.outlineWidth = config.outlineWidth; + cfg.outlineColor = config.outlineColor; + textRenderer_->drawText(font, text, x, y, cfg); + stats_.textChars += static_cast(text.size()); + } +} + +void RenderService::drawText(FontAsset *font, const std::string &text, + float x, float y, const TextConfig &config) { + String32 text32; + for (char c : text) { + text32.push_back(static_cast(c)); + } + drawText(font, text32, x, y, config); +} + +glm::vec2 RenderService::measureText(FontAsset *font, const String32 &text, + float fontSize) { + if (textRenderer_ && font) { + return textRenderer_->measureText(font, text, fontSize); + } + return glm::vec2(0.0f); +} + +RenderServiceStats RenderService::stats() const { + RenderServiceStats s = stats_; + if (renderer_) { + s.drawCalls = renderer_->drawCalls(); + s.spriteCount = renderer_->spriteCount(); + } + if (textRenderer_) { + s.drawCalls += textRenderer_->drawCalls(); + } + return s; +} + +void RenderService::resetStats() { + stats_ = RenderServiceStats{}; + fpsFrameCount_ = 0; + fpsAccumulator_ = 0.0f; +} + +RenderDevice &RenderService::device() { return RenderDevice::instance(); } + +Renderer *RenderService::renderer() { return renderer_.get(); } + +TextRenderer *RenderService::textRenderer() { return textRenderer_.get(); } + +void RenderService::onRender(RenderCallback callback) { + renderCallback_ = std::move(callback); +} + +void RenderService::setClearColor(const Color &color) { + clearColor_ = color; +} + +void RenderService::update(f32 dt) { + stats_.textChars = 0; + + if (renderCallback_) { + auto windowModule = Lifecycle::instance().module(); + if (windowModule) { + int width = windowModule->width(); + int height = windowModule->height(); + + Camera camera; + camera.setViewport(0, 0, width, height); + + beginFrame(clearColor_); + setCamera(camera); + renderCallback_(this, dt); + endFrame(); + } + } +} + +glm::vec4 RenderService::toVec4(const Color &color) const { + return glm::vec4(color.r, color.g, color.b, color.a); +} + +} // namespace extra2d diff --git a/examples/msdf_text_demo/main.cpp b/examples/msdf_text_demo/main.cpp new file mode 100644 index 0000000..6ac8cc5 --- /dev/null +++ b/examples/msdf_text_demo/main.cpp @@ -0,0 +1,155 @@ +/** + * @file main.cpp + * @brief MSDF 文字渲染示例 + * + * 演示 MSDF 字体的高质量文字渲染功能，使用 RenderService 服务。 + */ + +#include +#include + +using namespace extra2d; + +namespace { + +Ref g_font; + +} // namespace + +int main(int argc, char **argv) { + E2D_INFO(CAT_APP, "============================"); + E2D_INFO(CAT_APP, "MSDF Text Rendering Demo"); + E2D_INFO(CAT_APP, "============================"); + + auto &app = Application::instance(); + app.name = "MSDF Text Demo"; + + app.useService(); + app.useService(); + app.useService(); + app.useService(); + app.useService(); + + app.useModule([](WindowCfg &cfg) { + cfg.title = "Extra2D - MSDF Text Demo"; + cfg.width = 1280; + cfg.height = 720; + }); + + app.useModule([](RenderCfg &cfg) { + cfg.glMajor = 4; + cfg.glMinor = 5; + cfg.vsync = true; + }); + + if (!app.init()) { + E2D_ERROR(CAT_APP, "应用初始化失败！"); + return -1; + } + + auto renderService = app.service(); + if (!renderService) { + E2D_ERROR(CAT_APP, "无法获取 RenderService"); + app.shutdown(); + return -1; + } + + auto assetService = app.service(); + if (!assetService) { + E2D_ERROR(CAT_APP, "无法获取 AssetService"); + app.shutdown(); + return -1; + } + + auto fontHandle = assetService->load("assets/simhei.msdf.png"); + g_font = fontHandle.get(); + if (!g_font || !g_font->loaded()) { + E2D_ERROR(CAT_APP, "无法加载字体"); + app.shutdown(); + return -1; + } + + E2D_INFO(CAT_APP, "字体加载成功，字体大小: {}", g_font->fontSize()); + + auto eventService = app.service(); + if (eventService) { + eventService->on(EventType::KeyPressed, [&app](Event &e) { + auto &keyEvent = std::get(e.data); + if (keyEvent.key == static_cast(Key::Escape)) { + E2D_INFO(CAT_INPUT, "ESC 键按下，退出应用"); + app.quit(); + } + }); + } + + renderService->onRender([](IRenderService *render, f32 dt) { + if (!g_font) { + return; + } + + float y = 60.0f; + + ::extra2d::TextConfig config; + config.fontSize = 48.0f; + config.color = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f); + + render->drawText(g_font.get(), U"MSDF Text Rendering Demo", 20.0f, y, + config); + y += 80.0f; + + config.fontSize = 32.0f; + render->drawText(g_font.get(), U"Extra2D Engine - 2D Game Engine", 20.0f, y, + config); + y += 60.0f; + + config.fontSize = 24.0f; + config.color = glm::vec4(0.7f, 0.9f, 1.0f, 1.0f); + render->drawText(g_font.get(), U"High quality text rendering with MSDF", + 20.0f, y, config); + y += 45.0f; + + config.fontSize = 20.0f; + config.color = glm::vec4(1.0f, 0.8f, 0.4f, 1.0f); + render->drawText(g_font.get(), + U"Multi-channel Signed Distance Field technology", 20.0f, + y, config); + y += 35.0f; + + config.color = glm::vec4(0.6f, 1.0f, 0.6f, 1.0f); + render->drawText(g_font.get(), + U"Provides high quality, scalable vector font rendering", + 20.0f, y, config); + y += 50.0f; + + config.fontSize = 28.0f; + config.color = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f); + render->drawText(g_font.get(), U"Character Test:", 20.0f, y, config); + y += 45.0f; + + config.fontSize = 22.0f; + config.color = glm::vec4(0.9f, 0.9f, 0.9f, 1.0f); + render->drawText(g_font.get(), U"ABCDEFGHIJKLMNOPQRSTUVWXYZ", 20.0f, y, + config); + y += 35.0f; + render->drawText(g_font.get(), U"abcdefghijklmnopqrstuvwxyz", 20.0f, y, + config); + y += 35.0f; + render->drawText(g_font.get(), U"0123456789!@#$%^&*()[]{}<>", 20.0f, y, + config); + + static int frameCounter = 0; + if (++frameCounter % 60 == 0) { + auto stats = render->stats(); + E2D_DEBUG(CAT_RENDER, "FPS: {:.1f}, Draw Calls: {}", stats.fps, + stats.drawCalls); + } + }); + + E2D_INFO(CAT_APP, "开始主循环..."); + app.run(); + E2D_INFO(CAT_APP, "应用结束"); + + app.shutdown(); + + return 0; +} diff --git a/examples/msdf_text_demo/romfs/assets/simhei.msdf.png b/examples/msdf_text_demo/romfs/assets/simhei.msdf.png new file mode 100644 index 0000000000000000000000000000000000000000..b3227b947b125429ec03b655dc8f70b3c0066ad9 GIT binary patch literal 608734 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 +#include + +auto font = assetService->load("font.msdf.png"); + +TextRenderer renderer; +renderer.init(); +renderer.begin(projection); +renderer.drawText(font.get(), U"Hello, World!", 100, 100, { .fontSize = 32.0f }); +renderer.end(); +``` + +## 工作流程 + +``` +构建时: TTF ──► msdfgen 库 ──► MSDF PNG (内嵌 JSON 元数据) +运行时: FontLoader ──► FontAsset ──► TextRenderer +``` diff --git a/tools/msdf_font_builder/charset_default.txt b/tools/msdf_font_builder/charset_default.txt new file mode 100644 index 0000000..21b6c66 --- /dev/null +++ b/tools/msdf_font_builder/charset_default.txt @@ -0,0 +1,5 @@ + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ +的一是在不了有和人这中大为上个国我以要他时来用们生到作地于出就分对成会可主发年动同工也能下过子说产种面而方后多定行学法所民得经十三之进着等部度家电力里如水化高自二理起小物现实加量都两体制机当使点从业本去把性好应开它合还因由其些然前外天政四日那社义事平形相全表间样与关各重新线内数正心反你明看原又么利比或但质气第向道命此变条只没结解问意建月公无系军很情者最立代想已通并提直题党程展五果料象员革位入常文总次品式活设及管特件长求老头基资边流路级少图山统接知较将组见计别她手角期根论运农指几九区强放决西被干做必战先回则任取据处队南给色光门即保治北造百规热领七海口东导器压志世金增争济阶油思术极交受联什认六共权收证改清己美再采转更单风切打白教速花带安场身车例真务具万每目至达走积示议声报斗完类八离华名确才科张信马节话米整空元况今集温传土许步群广石记需段研界拉林律叫且究观越织装影算低持音众书布复容儿须际商非验连断深难近矿千周委素技备半办青省列习响约支般史感劳便团往酸历市克何除消构府称太准精值号率族维划选标写存候毛亲快效斯院查江型眼王按格养易置派层片始却专状育厂京识适属圆包火住调满县局照参红细引听该铁价严龙飞 +个们说也为得会这着来那要就自己去以和是人他对大们有上个这不为能可出在也我你她它 +爱被本比别并才从打大但当到的等地得都而对方分个给更过好还很会几家看可了来老里两吗们那你您能呢起去人让上谁什么他她它天为问我的我们向像小些一已有再在怎么这真着正知道只作做 +啊阿埃挨哎唉哀皑癌蔼矮艾碍爱隘鞍氨安俺按暗岸胺案肮昂盎凹敖熬翱袄傲奥懊澳芭捌扒叭吧笆八疤巴拔跋靶把耙坝霸罢爸白柏百摆佰败拜稗斑班搬扳般颁板版扮拌伴瓣半办绊邦帮梆榜膀绑棒磅蚌镑傍谤苞胞包褒剥薄雹保堡饱宝抱报暴豹鲍爆杯碑悲卑北辈背贝钡倍狈备惫焙被奔苯本笨崩绷甭泵蹦迸逼鼻比鄙笔彼碧蓖蔽毕毙毖币庇痹闭敝弊必辟壁臂避陛鞭边编贬扁便变卞辨辩辫遍标彪膘表鳖憋别瘪彬斌濒滨宾摈兵冰柄丙秉饼炳病并玻菠播拨钵波博勃搏铂箔伯帛舶脖膊渤泊驳捕卜哺补埠不布步簿部怖擦猜裁材才财睬踩采彩菜蔡餐参蚕残惭惨灿苍舱仓沧藏操糙槽曹草厕策侧册测层蹭插叉茬茶查碴搽察岔差诧拆柴豺搀掺蝉馋谗缠铲产阐颤昌猖场尝常长偿肠厂敞畅唱倡超抄钞朝嘲潮巢吵炒车扯撤掣彻澈郴臣辰尘晨忱沉陈趁衬撑称城橙成呈乘程惩澄诚承逞骋秤吃痴持匙池迟弛驰耻齿侈尺赤翅斥炽充冲虫崇宠抽酬畴踌稠愁筹仇绸瞅丑臭初出橱厨躇锄雏滁除楚础储矗搐触处揣川穿椽传船喘串疮窗幢床闯创吹炊捶锤垂春椿醇唇淳纯蠢戳绰疵茨磁雌辞慈瓷词此刺赐次聪葱囱匆从丛凑粗醋簇促蹿篡窜摧崔催脆瘁粹淬翠村存寸磋撮搓措挫错搭达答瘩打大呆歹傣戴带殆代贷袋待逮怠耽担丹单郸掸胆旦氮但惮淡诞弹蛋当挡党荡档刀捣蹈倒岛祷导到稻悼道盗德得的蹬灯登等瞪凳邓堤低滴迪敌的狄涤笛迪底地蒂第帝弟递缔颠掂滇碘点典靛垫电佃甸店惦奠淀殿碉叼雕凋刁掉吊钓调跌爹碟蝶迭谍叠丁盯叮钉顶鼎锭定订丢东冬董懂动栋侗恫冻洞兜抖斗陡豆逗痘都督毒犊独读堵睹赌杜镀肚度渡妒端短锻段断缎堆兑队对墩吨蹲敦顿囤钝盾遁掇哆多夺垛躲朵跺舵剁惰堕蛾峨鹅俄额讹娥恶厄扼遏鄂饿恩而儿耳尔饵洱二贰发罚筏伐乏阀法珐藩帆番翻樊矾钒繁凡烦反返范贩犯饭泛坊芳方肪房防妨仿访纺放菲非啡飞肥匪诽吠肺废沸费芬酚吩氛分纷坟焚汾粉奋份忿愤粪丰封枫蜂峰锋风疯烽逢冯缝讽奉凤佛否夫敷肤孵扶拂辐幅氟符伏俘服浮涪福袱弗甫抚辅俯釜斧脯腑府腐赴副覆赋复傅付阜父腹负富讣附妇缚咐噶嘎该改概钙盖溉干甘杆柑竿肝赶感秆敢赣冈刚钢缸肛纲岗港杠篙皋高膏羔糕搞镐稿告哥歌搁戈鸽胳疙割革葛格蛤阁隔铬个各给根跟耕更庚羹埂耿梗工攻功恭龚供躬公宫弓巩汞拱贡共钩勾沟苟狗垢构购够辜菇咕箍估沽孤姑鼓古蛊骨谷股故顾固雇刮瓜剐寡挂褂乖拐怪棺关官冠观管馆罐惯灌贯光广逛瑰规圭硅归龟闺轨鬼诡癸桂柜跪贵刽辊滚棍锅郭国果裹过哈骸孩海氦亥害骇酣憨邯韩含涵寒函喊罕翰撼捍旱憾悍焊汗汉夯杭航壕嚎豪毫郝好耗号浩呵喝荷菏核禾和何合盒貉阂河涸赫褐鹤贺嘿黑痕很狠恨哼亨横衡恒轰哄烘虹鸿洪宏弘红喉侯猴吼厚候后呼乎忽瑚壶葫胡蝴狐糊湖弧虎唬护互沪户花哗华猾滑画划化话槐徊怀淮坏欢环桓还缓换患唤痪豢焕涣宦幻荒慌黄磺蝗簧皇凰惶煌晃幌恍谎灰挥辉徽恢蛔回毁悔慧卉惠晦贿秽会烩汇讳诲绘荤昏婚魂浑混豁活伙火获或惑霍货祸击圾基机畸稽积箕肌饥迹激讥鸡姬绩缉吉极棘辑籍集及急疾汲即嫉级挤几脊己蓟技冀季伎祭剂悸济寄寂计记既忌际妓继纪嘉枷夹佳家加荚颊贾甲钾假稼价架驾嫁歼监坚尖笺间煎兼肩艰奸缄茧检柬碱碱拣捡简俭剪减荐槛鉴践贱见键箭件健舰剑饯渐溅涧建僵姜将浆江疆蒋桨奖讲匠酱降蕉椒礁焦胶交郊浇骄娇嚼搅铰矫侥脚狡角饺缴绞剿教酵轿较叫窖揭接皆秸街阶截劫节桔杰捷睫竭洁结解姐戒藉芥界借介疥诫届巾筋斤金今津襟紧锦仅谨进靳晋禁近烬浸尽劲荆兢茎睛晶鲸京惊精粳经井警景颈静境敬镜径痉靖竟竞净炯窘揪究纠玖韭久灸九酒厩救旧臼舅咎就疚鞠拘狙疽居驹菊局咀矩举沮聚拒据巨具距踞锯俱句惧炬剧捐鹃娟倦眷卷绢撅攫抉掘倔爵觉决诀绝均菌钧军君峻俊竣浚郡骏喀咖卡咯开揩楷凯慨刊堪勘坎砍看康慷糠扛抗亢炕考拷烤靠坷苛柯棵磕颗科壳咳可渴克刻客课肯啃垦恳坑吭空恐孔控抠口扣寇枯哭窟苦酷库裤夸垮挎跨胯块筷侩快宽款匡筐狂框矿眶旷况亏盔岿窥葵奎魁傀馈愧溃坤昆捆困括扩廓阔垃拉喇蜡腊辣啦莱来赖蓝婪栏拦篮阑兰澜谰揽览懒缆烂滥琅榔狼廊郎朗浪捞劳牢老佬姥酪烙涝勒乐雷镭蕾磊累儡垒擂肋类泪棱楞冷厘梨犁黎篱狸离漓理李里鲤礼莉荔吏栗丽厉励砾历利僳例俐痢立粒沥隶力璃哩俩联莲连镰廉怜涟帘敛脸链恋炼练粮凉梁粱良两辆量晾亮谅撩聊僚疗燎寥辽潦了撂镣廖料列裂烈劣猎琳林磷霖临邻鳞淋凛赁吝拎玲菱零龄铃伶羚凌灵陵岭领另令溜琉榴硫馏留刘瘤流柳六龙聋咙笼窿隆龙拢陇楼娄搂篓漏陋芦卢颅庐炉掳卤虏鲁麓碌露路赂鹿潞禄录陆戮驴吕铝侣旅履屡缕虑氯律率滤绿峦挛孪滦卵乱掠略抡轮伦仑沦纶论萝螺罗逻锣箩骡裸落洛骆络妈麻玛码蚂马骂嘛吗埋买麦卖迈脉瞒馒蛮满蔓曼慢漫谩芒茫盲氓忙莽猫茅锚毛矛铆卯茂冒帽貌贸么玫枚梅酶霉煤没眉媒镁每美昧寐妹媚门闷们萌蒙檬盟锰猛梦孟眯醚靡糜迷谜弥米秘觅泌蜜密幂棉眠绵冕免勉娩缅面苗描瞄藐秒渺庙妙蔑灭民抿皿敏悯闽明螟鸣铭名命谬摸摹蘑模膜磨摩魔抹末莫墨默沫漠寞陌谋牟某拇牡亩姆母墓暮幕募慕木目睦牧穆拿哪呐钠那娜纳氖乃奶耐奈南男难囊挠脑恼闹淖呢馁内嫩能妮霓倪泥尼拟你匿腻逆溺蔫拈年碾撵捻念娘酿鸟尿捏聂孽啮镊镍涅您柠狞凝宁拧泞牛扭钮纽脓浓农弄奴努怒女暖虐疟挪懦糯诺哦欧鸥殴藕呕偶沤啪趴爬帕怕琶拍排牌徘湃派攀潘盘磐盼畔判叛乓庞旁耪胖抛咆刨炮袍跑泡呸胚培裴赔陪配佩沛喷盆砰抨烹澎彭蓬棚硼篷膨朋鹏捧碰坯砒霹批披劈琵毗啤脾疲皮匹痞僻屁譬篇偏片骗飘漂瓢票撇瞥拼频贫品聘乒坪苹萍平凭瓶评屏坡泼颇婆破魄迫粕剖扑铺仆莆葡菩蒲埔朴圃普浦谱曝瀑期欺栖戚妻七凄漆柒沏其棋奇歧畦崎脐齐旗祈祁骑起岂乞企启契砌器气迄弃汽泣讫掐洽牵扦钎铅千迁签仟谦乾黔钱钳前潜遣浅谴堑嵌欠歉枪呛腔羌墙蔷强抢橇锹敲悄桥瞧乔侨巧鞘撬翘峭俏窍切茄且怯窃钦侵亲秦琴勤芹擒禽寝沁青轻氢倾卿清擎晴氰情顷请庆琼穷秋丘邱球求囚酋泅趋区蛆曲躯屈驱渠取娶龋趣去圈颧权醛泉全痊拳犬券劝缺炔瘸却鹊榷确雀裙群然燃冉染瓤壤攘嚷让饶扰绕惹热壬仁人忍韧任认刃妊纫扔仍日戎茸蓉荣融熔溶容绒冗揉柔肉茹蠕儒孺如辱乳汝入褥软阮蕊瑞锐闰润若弱撒洒萨腮鳃塞赛三叁伞散桑嗓丧搔骚扫嫂瑟色涩森僧莎砂杀刹沙纱傻啥煞筛晒珊苫杉山删煽衫闪陕擅赡膳善汕扇缮墒伤商赏晌上尚裳梢捎稍烧芍勺韶少哨邵绍奢赊蛇舌舍赦摄射慑涉社设砷申呻伸身深娠绅神沈审婶甚肾慎渗声生甥牲升绳省盛剩胜圣师狮施湿诗尸虱十石拾时什食蚀实识史矢使屎驶始式示士世柿事拭誓逝势是嗜噬适仕侍释饰视试收手首守寿授售受瘦兽蔬枢梳殊抒输叔舒淑疏书赎孰熟薯暑曙署蜀黍鼠属术述树束戍竖墅庶数漱恕刷耍摔衰甩帅栓拴霜双爽谁水睡税吮瞬顺舜说硕朔烁斯撕嘶思私司丝死肆寺嗣四伺似饲巳松耸怂颂送宋讼诵搜艘擞嗽苏酥俗素速粟僳塑溯诉肃酸蒜算虽隋随绥髓碎岁穗遂隧祟孙损笋蓑梭唆缩琐索锁所塌他它她塔獭挞蹋踏胎苔抬台泰酞太态汰坍摊贪瘫滩坛檀痰潭谭谈坦毯袒碳探叹炭汤塘搪堂棠膛唐糖倘躺淌趟烫掏涛滔绦萄桃逃淘陶讨套特藤腾疼誊梯剔踢锑提题蹄啼体替嚏惕涕剃屉天添填田甜恬舔腆挑条迢眺跳贴铁帖厅听烃汀廷停亭庭艇通桐酮瞳同铜彤童桶捅筒统痛偷投头透凸秃突图徒途涂屠土吐兔湍团推颓腿蜕褪退吞屯臀拖托脱鸵陀驮驼椭妥拓唾挖哇蛙洼娃瓦袜歪外豌弯湾玩顽丸烷完碗挽晚皖惋宛婉万腕汪王亡枉网往旺望忘妄威巍微危韦违桅围唯惟为潍维苇萎委伟伪尾纬未蔚味畏胃喂魏位渭谓尉慰卫瘟温蚊文闻纹吻稳紊问嗡翁瓮挝蜗涡窝我斡卧握沃巫呜钨乌污诬屋无芜梧吾吴毋武五捂午舞伍侮坞戊雾晤物勿务悟误昔熙析西硒矽晰嘻吸锡牺稀息希悉膝夕惜熄烯溪汐犀檄袭席习媳喜铣洗系隙戏细瞎虾匣霞辖暇峡侠狭下厦夏吓掀锨先仙鲜纤咸贤衔舷闲涎弦嫌显险现献县腺馅羡宪陷限线相厢镶香箱襄湘乡翔祥详想响享项巷橡像向象萧硝霄削哮嚣销消宵淆晓小孝校肖啸笑效楔些歇蝎鞋协挟携邪斜胁谐写械卸蟹懈泄泻谢屑薪芯锌欣辛新忻心信衅星腥猩惺兴刑型形邢行醒幸杏性姓兄凶胸匈汹雄熊休修羞朽嗅锈秀袖绣墟戌需虚嘘须徐许蓄酗叙旭序畜恤絮婿绪续轩喧宣悬旋玄选癣眩绚靴薛学穴雪血勋熏循旬询寻驯巡殉汛训讯逊迅压押鸦鸭呀丫芽牙蚜崖衙涯雅哑亚讶焉咽阉烟淹盐严研蜒岩延言颜阎炎沿奄掩眼衍演艳堰燕厌砚雁唁彦焰宴谚验殃央鸯秧杨扬佯疡羊洋阳氧仰痒养样漾邀腰妖瑶摇尧遥窑谣姚咬舀药要耀椰噎耶爷野冶也页掖业叶曳腋夜液一壹医揖铱依伊衣颐夷遗移仪胰疑沂宜姨彝椅蚁倚已乙矣以艺抑易邑屹亿役臆逸肄疫亦裔意毅忆义益溢诣议谊译异翼翌绎茵荫因殷音阴姻吟银淫寅饮尹引隐印英樱婴鹰应缨莹萤营荧蝇迎赢盈影颖硬映哟拥佣臃痈庸雍踊蛹咏泳涌永恿勇用幽优悠忧尤由邮铀犹油游酉有友右佑釉诱又幼迂淤于盂榆虞愚舆余俞逾鱼愉渝渔隅予娱雨与屿禹宇语羽玉域芋郁吁遇喻峪御愈欲狱育誉浴寓裕预豫驭鸳渊冤元垣袁原援辕园员圆猿源缘远苑愿怨院曰约越跃钥岳粤月悦阅耘云郧匀陨允运蕴酝晕韵孕匝砸杂栽哉灾宰载再在咱攒暂赞赃脏葬遭糟凿藻枣早澡蚤躁噪造皂灶燥责择则泽贼怎增憎曾赠扎喳渣札轧铡闸眨栅榨咋乍炸诈摘斋宅窄债寨瞻毡詹粘沾盏斩辗崭展蘸栈占战站湛绽樟章彰漳张掌涨杖丈帐账仗胀瘴障招昭找沼赵照罩兆肇召遮折哲蛰辙者锗蔗这浙珍斟真甄砧臻贞针侦枕疹诊震振镇阵蒸挣睁征狰争怔整拯正政帧症郑证芝枝支吱蜘知肢脂汁之织职直植殖执值侄址指止趾只旨纸志挚掷至致置帜峙制智秩稚质炙痔滞治窒中盅忠钟衷终种肿重仲众舟周州洲诌粥轴肘帚咒皱宙昼骤珠株蛛朱猪诸诛逐竹烛煮拄瞩嘱主著柱助蛀贮铸筑住注祝驻抓爪拽专砖转撰赚篆桩庄装妆撞壮状椎锥追赘坠缀谆准捉拙卓桌琢茁酌啄着灼浊兹咨资姿滋淄孜紫仔籽滓子自渍字鬃棕踪宗综总纵邹走奏揍租足卒族祖诅阻组钻纂嘴醉最罪尊遵昨左佐柞做作坐座 diff --git a/tools/msdf_font_builder/main.cpp b/tools/msdf_font_builder/main.cpp new file mode 100644 index 0000000..755abeb --- /dev/null +++ b/tools/msdf_font_builder/main.cpp @@ -0,0 +1,100 @@ +/** + * @file main.cpp + * @brief MSDF 字体构建工具命令行入口 + * + * 用法: + * msdf_font_builder -i -o [options] + * + * 选项: + * -i, --input 输入 TTF 字体文件路径 + * -o, --output 输出 PNG 图集路径 + * -c, --charset 字符集字符串 + * -f, --charset-file 字符集文件路径 + * -s, --size 字体大小（默认 48） + * -r, --range 像素范围（默认 4.0） + * -w, --width 图集宽度（默认 2048） + * -h, --height 图集高度（默认 2048） + * --help 显示帮助信息 + */ + +#include "msdf_font_builder.h" +#include +#include +#include + +using namespace extra2d::tools; + +void printUsage(const char* programName) { + std::cout << "MSDF Font Builder - TTF 转 MSDF PNG 图集工具\n\n"; + std::cout << "用法:\n"; + std::cout << " " << programName << " -i -o [options]\n\n"; + std::cout << "选项:\n"; + std::cout << " -i, --input 输入 TTF 字体文件路径\n"; + std::cout << " -o, --output 输出 PNG 图集路径\n"; + std::cout << " -c, --charset 字符集字符串\n"; + std::cout << " -f, --charset-file 字符集文件路径\n"; + std::cout << " -s, --size 字体大小（默认 48）\n"; + std::cout << " -r, --range 像素范围（默认 4.0）\n"; + std::cout << " -w, --width 图集宽度（默认 2048）\n"; + std::cout << " -h, --height 图集高度（默认 2048）\n"; + std::cout << " --help 显示帮助信息\n\n"; + std::cout << "示例:\n"; + std::cout << " " << programName << " -i font.ttf -o font.msdf.png\n"; + std::cout << " " << programName << " -i font.ttf -o font.msdf.png -s 64 -c \"ABCabc123\"\n"; + std::cout << " " << programName << " -i font.ttf -o font.msdf.png -f charset.txt\n"; +} + +int main(int argc, char* argv[]) { + MSDFFontBuilder builder; + bool showHelp = false; + int width = 2048; + int height = 2048; + + for (int i = 1; i < argc; ++i) { + std::string arg = argv[i]; + + if (arg == "--help") { + showHelp = true; + } else if ((arg == "-i" || arg == "--input") && i + 1 < argc) { + builder.setInputFont(argv[++i]); + } else if ((arg == "-o" || arg == "--output") && i + 1 < argc) { + builder.setOutputPath(argv[++i]); + } else if ((arg == "-c" || arg == "--charset") && i + 1 < argc) { + builder.setCharset(argv[++i]); + } else if ((arg == "-f" || arg == "--charset-file") && i + 1 < argc) { + builder.setCharsetFile(argv[++i]); + } else if ((arg == "-s" || arg == "--size") && i + 1 < argc) { + builder.setFontSize(std::atoi(argv[++i])); + } else if ((arg == "-r" || arg == "--range") && i + 1 < argc) { + builder.setPxRange(static_cast(std::atof(argv[++i]))); + } else if ((arg == "-w" || arg == "--width") && i + 1 < argc) { + width = std::atoi(argv[++i]); + } else if ((arg == "-h" || arg == "--height") && i + 1 < argc) { + height = std::atoi(argv[++i]); + } else { + std::cerr << "未知参数: " << arg << "\n"; + showHelp = true; + } + } + + builder.setAtlasSize(width, height); + + if (showHelp) { + printUsage(argv[0]); + return 0; + } + + std::cout << "MSDF Font Builder\n"; + std::cout << "==================\n\n"; + std::cout << "开始构建...\n\n"; + + if (!builder.build()) { + std::cerr << "错误: " << builder.getError() << "\n"; + return 1; + } + + std::cout << "成功生成 MSDF 字体图集!\n"; + std::cout << "字形数量: " << builder.getMetadata().glyphs.size() << "\n"; + + return 0; +} diff --git a/tools/msdf_font_builder/msdf_font_builder.cpp b/tools/msdf_font_builder/msdf_font_builder.cpp new file mode 100644 index 0000000..0cd1dc4 --- /dev/null +++ b/tools/msdf_font_builder/msdf_font_builder.cpp @@ -0,0 +1,588 @@ +#include "msdf_font_builder.h" + +#include + +#include +#include FT_FREETYPE_H +#include FT_OUTLINE_H + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include + +#include +#include +#include +#include +#include + +namespace extra2d { +namespace tools { + +using namespace msdfgen; + +/** + * @brief Freetype 轮廓转换上下文 + */ +struct OutlineContext { + Shape* shape; + Contour* currentContour; + Point2 lastPoint; + bool hasLastPoint; + std::map advanceMap; +}; + +/** + * @brief MSDF 字体构建器实现 + */ +struct MSDFFontBuilder::Impl { + FT_Library ftLibrary = nullptr; + FT_Face ftFace = nullptr; + OutlineContext outlineCtx; + + struct GlyphBitmap { + char32_t codepoint; + Bitmap bitmap; + double advance; + double l, b, r, t; + double pl, pb, pr, pt; + }; + + std::vector glyphBitmaps; +}; + +/** + * @brief Freetype 移动到点回调函数 + */ +static int ftMoveTo(const FT_Vector* to, void* user) { + OutlineContext* ctx = static_cast(user); + ctx->currentContour = &ctx->shape->addContour(); + ctx->lastPoint = Point2(to->x / 64.0, to->y / 64.0); + ctx->hasLastPoint = true; + return 0; +} + +/** + * @brief Freetype 画线回调函数 + */ +static int ftLineTo(const FT_Vector* to, void* user) { + OutlineContext* ctx = static_cast(user); + if (ctx->currentContour && ctx->hasLastPoint) { + Point2 endPoint(to->x / 64.0, to->y / 64.0); + ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, endPoint)); + ctx->lastPoint = endPoint; + } + return 0; +} + +/** + * @brief Freetype 二次贝塞尔曲线回调函数 + */ +static int ftConicTo(const FT_Vector* control, const FT_Vector* to, void* user) { + OutlineContext* ctx = static_cast(user); + if (ctx->currentContour && ctx->hasLastPoint) { + Point2 controlPoint(control->x / 64.0, control->y / 64.0); + Point2 endPoint(to->x / 64.0, to->y / 64.0); + ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, controlPoint, endPoint)); + ctx->lastPoint = endPoint; + } + return 0; +} + +/** + * @brief Freetype 三次贝塞尔曲线回调函数 + */ +static int ftCubicTo(const FT_Vector* control1, const FT_Vector* control2, const FT_Vector* to, void* user) { + OutlineContext* ctx = static_cast(user); + if (ctx->currentContour && ctx->hasLastPoint) { + Point2 cp1(control1->x / 64.0, control1->y / 64.0); + Point2 cp2(control2->x / 64.0, control2->y / 64.0); + Point2 endPoint(to->x / 64.0, to->y / 64.0); + ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, cp1, cp2, endPoint)); + ctx->lastPoint = endPoint; + } + return 0; +} + +MSDFFontBuilder::MSDFFontBuilder() : impl_(new Impl()) { +} + +MSDFFontBuilder::~MSDFFontBuilder() { + if (impl_) { + if (impl_->ftFace) { + FT_Done_Face(impl_->ftFace); + } + if (impl_->ftLibrary) { + FT_Done_FreeType(impl_->ftLibrary); + } + delete impl_; + } +} + +void MSDFFontBuilder::setInputFont(const std::string& path) { + inputFont_ = path; +} + +void MSDFFontBuilder::setOutputPath(const std::string& path) { + outputPath_ = path; +} + +void MSDFFontBuilder::setCharset(const std::string& charset) { + charset_ = charset; +} + +void MSDFFontBuilder::setCharsetFile(const std::string& path) { + charsetFile_ = path; +} + +void MSDFFontBuilder::setFontSize(int size) { + fontSize_ = size; +} + +void MSDFFontBuilder::setPxRange(float range) { + pxRange_ = range; +} + +void MSDFFontBuilder::setAtlasSize(int width, int height) { + atlasWidth_ = width; + atlasHeight_ = height; +} + +bool MSDFFontBuilder::build() { + if (inputFont_.empty()) { + error_ = "Input font path not set"; + return false; + } + + if (outputPath_.empty()) { + error_ = "Output path not set"; + return false; + } + + if (!loadCharset()) { + return false; + } + + FT_Error error = FT_Init_FreeType(&impl_->ftLibrary); + if (error) { + error_ = "Failed to initialize FreeType"; + return false; + } + + error = FT_New_Face(impl_->ftLibrary, inputFont_.c_str(), 0, &impl_->ftFace); + if (error) { + error_ = "Failed to load font: " + inputFont_; + return false; + } + + error = FT_Set_Char_Size(impl_->ftFace, fontSize_ * 64, fontSize_ * 64, 72, 72); + if (error) { + error_ = "Failed to set font size"; + return false; + } + + if (!generateAllGlyphs()) { + return false; + } + + if (!packGlyphs()) { + return false; + } + + if (!savePngWithMetadata()) { + return false; + } + + return true; +} + +bool MSDFFontBuilder::loadCharset() { + if (!charsetFile_.empty()) { + std::ifstream file(charsetFile_); + if (!file) { + error_ = "Failed to open charset file: " + charsetFile_; + return false; + } + std::stringstream buffer; + buffer << file.rdbuf(); + charset_ = buffer.str(); + } + + if (charset_.empty()) { + charset_ = " !\"#$%&'()*+,-./0123456789:;<=>?@" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`" + "abcdefghijklmnopqrstuvwxyz{|}~"; + } + + return true; +} + +/** + * @brief 从 Freetype 字形加载 msdfgen Shape + */ +static bool loadGlyphShape(FT_Face face, char32_t codepoint, Shape& shape, double& advance) { + FT_UInt glyphIndex = FT_Get_Char_Index(face, codepoint); + if (glyphIndex == 0) { + return false; + } + + FT_Error error = FT_Load_Glyph(face, glyphIndex, FT_LOAD_NO_SCALE); + if (error) { + return false; + } + + advance = face->glyph->metrics.horiAdvance / 64.0; + + FT_Outline* outline = &face->glyph->outline; + if (outline->n_contours == 0) { + return false; + } + + OutlineContext ctx; + ctx.shape = &shape; + ctx.currentContour = nullptr; + ctx.hasLastPoint = false; + + FT_Outline_Funcs funcs; + funcs.move_to = ftMoveTo; + funcs.line_to = ftLineTo; + funcs.conic_to = ftConicTo; + funcs.cubic_to = ftCubicTo; + funcs.shift = 0; + funcs.delta = 0; + + error = FT_Outline_Decompose(outline, &funcs, &ctx); + if (error) { + return false; + } + + return true; +} + +bool MSDFFontBuilder::generateAllGlyphs() { + impl_->glyphBitmaps.clear(); + + double unitsPerEM = impl_->ftFace->units_per_EM; + if (unitsPerEM == 0) { + unitsPerEM = 1000.0; + } + double scale = fontSize_ / unitsPerEM; + + for (char c : charset_) { + char32_t codepoint = static_cast(static_cast(c)); + + Shape shape; + double glyphAdvance = 0.0; + if (!loadGlyphShape(impl_->ftFace, codepoint, shape, glyphAdvance)) { + continue; + } + + shape.normalize(); + + edgeColoringSimple(shape, 3.0); + + Shape::Bounds bounds = shape.getBounds(); + double l = bounds.l; + double b = bounds.b; + double r = bounds.r; + double t = bounds.t; + + if (l >= r || b >= t) { + continue; + } + + double pl = l * scale; + double pb = b * scale; + double pr = r * scale; + double pt = t * scale; + + double range = pxRange_ / scale; + l -= range; + b -= range; + r += range; + t += range; + + double width = (r - l) * scale; + double height = (t - b) * scale; + + int w = static_cast(std::ceil(width)); + int h = static_cast(std::ceil(height)); + + w = std::max(w, 1); + h = std::max(h, 1); + + Impl::GlyphBitmap gb; + gb.codepoint = codepoint; + gb.advance = glyphAdvance * scale; + gb.l = l; + gb.b = b; + gb.r = r; + gb.t = t; + gb.pl = pl; + gb.pb = pb; + gb.pr = pr; + gb.pt = pt; + + gb.bitmap = Bitmap(w, h); + + MSDFGeneratorConfig config; + config.overlapSupport = true; + + Projection projection(Vector2(scale, scale), Vector2(-l * scale, -b * scale)); + Range distanceRange(range * scale); + generateMSDF(gb.bitmap, shape, projection, distanceRange, config); + + impl_->glyphBitmaps.push_back(std::move(gb)); + } + + return !impl_->glyphBitmaps.empty(); +} + +bool MSDFFontBuilder::packGlyphs() { + std::vector positions(impl_->glyphBitmaps.size() * 2, 0); + + std::vector> sizes; + for (const auto& gb : impl_->glyphBitmaps) { + sizes.emplace_back(gb.bitmap.width(), gb.bitmap.height()); + } + + std::vector indices(sizes.size()); + for (size_t i = 0; i < indices.size(); ++i) { + indices[i] = static_cast(i); + } + + std::sort(indices.begin(), indices.end(), [&](int a, int b) { + return sizes[a].second > sizes[b].second; + }); + + int x = 0, y = 0; + int rowHeight = 0; + + for (int idx : indices) { + int w = sizes[idx].first; + int h = sizes[idx].second; + + if (x + w > atlasWidth_) { + x = 0; + y += rowHeight; + rowHeight = 0; + } + + if (y + h > atlasHeight_) { + error_ = "Atlas size too small for all glyphs"; + return false; + } + + positions[idx * 2] = x; + positions[idx * 2 + 1] = y; + + x += w; + rowHeight = std::max(rowHeight, h); + } + + Bitmap atlas(atlasWidth_, atlasHeight_); + + for (int py = 0; py < atlasHeight_; ++py) { + for (int px = 0; px < atlasWidth_; ++px) { + float* pixel = atlas(px, py); + pixel[0] = 0.0f; + pixel[1] = 0.0f; + pixel[2] = 0.0f; + } + } + + for (size_t i = 0; i < impl_->glyphBitmaps.size(); ++i) { + const auto& gb = impl_->glyphBitmaps[i]; + int px = positions[i * 2]; + int py = positions[i * 2 + 1]; + + for (int gy = 0; gy < gb.bitmap.height(); ++gy) { + for (int gx = 0; gx < gb.bitmap.width(); ++gx) { + int targetY = atlasHeight_ - 1 - (py + gy); + float* pixel = atlas(px + gx, targetY); + const float* srcPixel = gb.bitmap(gx, gy); + pixel[0] = srcPixel[0]; + pixel[1] = srcPixel[1]; + pixel[2] = srcPixel[2]; + } + } + + GlyphData glyph; + glyph.codepoint = gb.codepoint; + glyph.advance = static_cast(gb.advance); + + glyph.left = static_cast(px); + glyph.top = static_cast(atlasHeight_ - py - gb.bitmap.height()); + glyph.right = static_cast(px + gb.bitmap.width()); + glyph.bottom = static_cast(atlasHeight_ - py); + + glyph.uvMin.x = static_cast(glyph.left / atlasWidth_); + glyph.uvMin.y = static_cast(glyph.top / atlasHeight_); + glyph.uvMax.x = static_cast(glyph.right / atlasWidth_); + glyph.uvMax.y = static_cast(glyph.bottom / atlasHeight_); + + glyph.size.x = static_cast(gb.pr - gb.pl); + glyph.size.y = static_cast(gb.pt - gb.pb); + glyph.bearing.x = static_cast(gb.pl); + glyph.bearing.y = static_cast(gb.pt); + + metadata_.glyphs.push_back(glyph); + } + + metadata_.fontSize = fontSize_; + metadata_.pxRange = pxRange_; + metadata_.atlasWidth = atlasWidth_; + metadata_.atlasHeight = atlasHeight_; + metadata_.lineHeight = static_cast(fontSize_ * 1.25); + metadata_.baseline = static_cast(fontSize_ * 0.25); + + impl_->glyphBitmaps.clear(); + impl_->glyphBitmaps.push_back({0, std::move(atlas), 0, 0, 0, 0, 0, 0, 0, 0, 0}); + + return true; +} + +bool MSDFFontBuilder::savePngWithMetadata() { + if (impl_->glyphBitmaps.empty()) { + error_ = "No atlas generated"; + return false; + } + + const auto& atlas = impl_->glyphBitmaps[0].bitmap; + + std::vector rgbaData(atlasWidth_ * atlasHeight_ * 4); + for (int y = 0; y < atlasHeight_; ++y) { + for (int x = 0; x < atlasWidth_; ++x) { + const float* pixel = atlas(x, y); + int idx = (y * atlasWidth_ + x) * 4; + rgbaData[idx + 0] = static_cast(std::clamp(pixel[0] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f); + rgbaData[idx + 1] = static_cast(std::clamp(pixel[1] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f); + rgbaData[idx + 2] = static_cast(std::clamp(pixel[2] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f); + rgbaData[idx + 3] = 255; + } + } + + std::string jsonStr = generateMetadataJson(); + std::vector textChunk; + + std::string keyword = "msdf"; + textChunk.insert(textChunk.end(), keyword.begin(), keyword.end()); + textChunk.push_back(0); + textChunk.insert(textChunk.end(), jsonStr.begin(), jsonStr.end()); + + uint32_t length = static_cast(textChunk.size()); + std::vector lengthBytes(4); + lengthBytes[0] = (length >> 24) & 0xFF; + lengthBytes[1] = (length >> 16) & 0xFF; + lengthBytes[2] = (length >> 8) & 0xFF; + lengthBytes[3] = length & 0xFF; + + std::vector crcData; + crcData.insert(crcData.end(), {'t', 'E', 'X', 't'}); + crcData.insert(crcData.end(), textChunk.begin(), textChunk.end()); + + uint32_t crc = 0xFFFFFFFF; + for (uint8_t byte : crcData) { + crc ^= byte; + for (int i = 0; i < 8; ++i) { + crc = (crc >> 1) ^ ((crc & 1) ? 0xEDB88320 : 0); + } + } + crc ^= 0xFFFFFFFF; + + std::vector crcBytes(4); + crcBytes[0] = (crc >> 24) & 0xFF; + crcBytes[1] = (crc >> 16) & 0xFF; + crcBytes[2] = (crc >> 8) & 0xFF; + crcBytes[3] = crc & 0xFF; + + std::string tempPng = outputPath_ + ".tmp.png"; + + if (!stbi_write_png(tempPng.c_str(), atlasWidth_, atlasHeight_, 4, rgbaData.data(), atlasWidth_ * 4)) { + error_ = "Failed to save PNG: " + tempPng; + return false; + } + + std::ifstream inputFile(tempPng, std::ios::binary); + if (!inputFile) { + error_ = "Failed to open temporary PNG file"; + return false; + } + + std::vector pngData((std::istreambuf_iterator(inputFile)), + std::istreambuf_iterator()); + inputFile.close(); + + std::vector newPng; + newPng.insert(newPng.end(), pngData.begin(), pngData.begin() + 8); + + size_t pos = 8; + bool inserted = false; + while (pos < pngData.size()) { + if (pos + 8 > pngData.size()) break; + + std::string chunkType(pngData.begin() + pos + 4, pngData.begin() + pos + 8); + + if (!inserted && chunkType != "IHDR") { + newPng.insert(newPng.end(), lengthBytes.begin(), lengthBytes.end()); + newPng.insert(newPng.end(), {'t', 'E', 'X', 't'}); + newPng.insert(newPng.end(), textChunk.begin(), textChunk.end()); + newPng.insert(newPng.end(), crcBytes.begin(), crcBytes.end()); + inserted = true; + } + + uint32_t chunkLen = (static_cast(pngData[pos]) << 24) | + (static_cast(pngData[pos + 1]) << 16) | + (static_cast(pngData[pos + 2]) << 8) | + static_cast(pngData[pos + 3]); + + size_t chunkEnd = pos + 12 + chunkLen; + newPng.insert(newPng.end(), pngData.begin() + pos, pngData.begin() + chunkEnd); + pos = chunkEnd; + } + + std::ofstream outputFile(outputPath_, std::ios::binary); + if (!outputFile) { + error_ = "Failed to write PNG file: " + outputPath_; + return false; + } + outputFile.write(reinterpret_cast(newPng.data()), newPng.size()); + + std::remove(tempPng.c_str()); + + return true; +} + +std::string MSDFFontBuilder::generateMetadataJson() { + nlohmann::json j; + + j["size"] = metadata_.fontSize; + j["pxRange"] = metadata_.pxRange; + j["lineHeight"] = metadata_.lineHeight; + j["baseline"] = metadata_.baseline; + + j["atlas"]["width"] = metadata_.atlasWidth; + j["atlas"]["height"] = metadata_.atlasHeight; + + for (const auto& glyph : metadata_.glyphs) { + nlohmann::json glyphJson; + glyphJson["unicode"] = static_cast(glyph.codepoint); + glyphJson["advance"] = glyph.advance; + + glyphJson["atlasBounds"]["left"] = glyph.left; + glyphJson["atlasBounds"]["bottom"] = glyph.bottom; + glyphJson["atlasBounds"]["right"] = glyph.right; + glyphJson["atlasBounds"]["top"] = glyph.top; + + glyphJson["planeBounds"]["left"] = glyph.bearing.x; + glyphJson["planeBounds"]["bottom"] = glyph.bearing.y - glyph.size.y; + glyphJson["planeBounds"]["right"] = glyph.bearing.x + glyph.size.x; + glyphJson["planeBounds"]["top"] = glyph.bearing.y; + + j["glyphs"].push_back(glyphJson); + } + + return j.dump(); +} + +} // namespace tools +} // namespace extra2d diff --git a/tools/msdf_font_builder/msdf_font_builder.h b/tools/msdf_font_builder/msdf_font_builder.h new file mode 100644 index 0000000..237feed --- /dev/null +++ b/tools/msdf_font_builder/msdf_font_builder.h @@ -0,0 +1,143 @@ +#pragma once + +#include +#include +#include +#include + +namespace extra2d { +namespace tools { + +/** + * @brief 字符字形信息 + */ +struct GlyphData { + char32_t codepoint = 0; + glm::vec2 uvMin; + glm::vec2 uvMax; + glm::vec2 size; + glm::vec2 bearing; + float advance = 0.0f; + + double left = 0.0; + double bottom = 0.0; + double right = 0.0; + double top = 0.0; +}; + +/** + * @brief MSDF 字体图集元数据 + */ +struct MSDFMetadata { + int fontSize = 48; + float pxRange = 4.0f; + int atlasWidth = 2048; + int atlasHeight = 2048; + int lineHeight = 60; + int baseline = 12; + std::vector glyphs; +}; + +/** + * @brief MSDF 字体构建器 + * + * 直接使用 msdfgen 库将 TTF 字体转换为 MSDF PNG 图集。 + */ +class MSDFFontBuilder { +public: + MSDFFontBuilder(); + ~MSDFFontBuilder(); + + /** + * @brief 设置输入 TTF 字体文件路径 + */ + void setInputFont(const std::string &path); + + /** + * @brief 设置输出 PNG 文件路径 + */ + void setOutputPath(const std::string &path); + + /** + * @brief 设置字符集 + */ + void setCharset(const std::string &charset); + + /** + * @brief 设置字符集文件路径 + */ + void setCharsetFile(const std::string &path); + + /** + * @brief 设置字体大小 + */ + void setFontSize(int size); + + /** + * @brief 设置像素范围 + */ + void setPxRange(float range); + + /** + * @brief 设置图集尺寸 + */ + void setAtlasSize(int width, int height); + + /** + * @brief 构建字体图集 + */ + bool build(); + + /** + * @brief 获取错误信息 + */ + const std::string &getError() const { return error_; } + + /** + * @brief 获取元数据 + */ + const MSDFMetadata &getMetadata() const { return metadata_; } + +private: + std::string inputFont_; + std::string outputPath_; + std::string charset_; + std::string charsetFile_; + int fontSize_ = 48; + float pxRange_ = 4.0f; + int atlasWidth_ = 2048; + int atlasHeight_ = 2048; + MSDFMetadata metadata_; + std::string error_; + + struct Impl; + Impl *impl_ = nullptr; + + /** + * @brief 加载字符集 + */ + bool loadCharset(); + + /** + * @brief 生成所有字形的 MSDF + */ + bool generateAllGlyphs(); + + /** + * @brief 打包字形到图集 + */ + bool packGlyphs(); + + /** + * @brief 保存 PNG 并嵌入元数据 + */ + bool savePngWithMetadata(); + + /** + * @brief 生成 JSON 元数据 + */ + std::string generateMetadataJson(); +}; + +} // namespace tools +} // namespace extra2d diff --git a/xmake.lua b/xmake.lua index 12c5be4..b056656 100644 --- a/xmake.lua +++ b/xmake.lua @@ -72,7 +72,7 @@ end -- ============================================== if target_plat == "mingw" then - add_requires("glm", "libsdl2", "libsdl2_mixer", "zstd", "lz4", "zlib", "libsodium") + add_requires("glm", "libsdl2", "libsdl2_mixer", "zstd", "lz4", "zlib", "libsodium", "nlohmann_json", "msdfgen", "freetype") end -- ============================================== @@ -85,9 +85,19 @@ includes("xmake/engine.lua") -- 定义引擎库 define_extra2d_engine() +-- MSDF 字体构建工具 +target("msdf_font_builder") + set_kind("binary") + add_files("tools/msdf_font_builder/main.cpp", "tools/msdf_font_builder/msdf_font_builder.cpp") + add_includedirs("tools/msdf_font_builder", "Extra2D/include", "Extra2D/include/stb") + add_packages("glm", "nlohmann_json", "msdfgen", "freetype") + add_defines("MSDFGEN_USE_CPP11") + set_default(false) + -- 示例程序目标（作为子项目） if is_config("examples","true") then includes("examples/hello_world", {rootdir = "examples/hello_world"}) + includes("examples/msdf_text_demo", {rootdir = "examples/msdf_text_demo"}) end -- ==============================================