@next2d/builder 0.1.8 → 0.1.11

package/templates/xbox/src/platform/AudioEngine.cpp

@@ -1,12 +1,18 @@
 #include "AudioEngine.h"
+#include "AudioDecoder.h"
 
 #include <xaudio2.h>
+#include <iostream>
+
+// Media Foundation / shlwapi はコンソール (Game Core OS) に無いデスクトップ専用 API。
+// 第一経路は AudioDecoder (dr_mp3/dr_wav/stb_vorbis) で、MF は AAC 等の
+// デスクトップ限定フォールバックのみ。XAudio2 は両プラットフォームで使える。
+#if !NEXT2D_XBOX_CONSOLE
 #include <mfapi.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <shlwapi.h>
 #include <wrl/client.h>
-#include <iostream>
 
 #pragma comment(lib, "mfplat.lib")
 #pragma comment(lib, "mfreadwrite.lib")
@@ -14,6 +20,7 @@
 #pragma comment(lib, "shlwapi.lib")
 
 using Microsoft::WRL::ComPtr;
+#endif
 
 namespace next2d {
 
@@ -97,15 +104,19 @@ AudioEngine::~AudioEngine()
     if (xaudio_) {
         xaudio_->Release();
     }
+#if !NEXT2D_XBOX_CONSOLE
     MFShutdown();
+#endif
 }
 
 bool AudioEngine::Initialize()
 {
+#if !NEXT2D_XBOX_CONSOLE
     if (FAILED(MFStartup(MF_VERSION))) {
         std::cerr << "[Audio] MFStartup failed" << std::endl;
         return false;
     }
+#endif
     if (FAILED(XAudio2Create(&xaudio_, 0, XAUDIO2_DEFAULT_PROCESSOR))) {
         std::cerr << "[Audio] XAudio2Create failed" << std::endl;
         return false;
@@ -119,8 +130,21 @@ bool AudioEngine::Initialize()
 
 bool AudioEngine::Decode(const std::vector<uint8_t>& input, PcmBuffer& out)
 {
-    // メモリストリームから Media Foundation の SourceReader を作り、
-    // 32bit float PCM へ変換して読み出す。
+    // 第一候補: ポータブルデコーダ (dr_mp3/dr_wav/stb_vorbis)。
+    // コンソール (Game Core) には Media Foundation が無いため、共通経路を先に
+    // 通すことで PC 検証と実機の挙動を一致させる。
+    if (DecodeAudio(input, out)) {
+        return true;
+    }
+
+#if NEXT2D_XBOX_CONSOLE
+    // コンソール: MF が無いため共通デコーダで扱えない形式は失敗とする
+    // (呼び出し側の graceful degradation = 無音バッファで進行)。
+    return false;
+#else
+    // フォールバック (デスクトップのみ): Media Foundation の SourceReader。
+    // AAC/WMA 等、MP3/WAV/OGG 以外の形式への保険。
+    // メモリストリームから 32bit float PCM へ変換して読み出す。
     ComPtr<IStream> stream =
         SHCreateMemStream(input.data(), static_cast<UINT>(input.size()));
     if (!stream) {
@@ -180,6 +204,7 @@ bool AudioEngine::Decode(const std::vector<uint8_t>& input, PcmBuffer& out)
     }
 
     return !out.samples.empty();
+#endif // NEXT2D_XBOX_CONSOLE
 }
 
 std::shared_ptr<AudioVoice> AudioEngine::CreateVoice(std::shared_ptr<PcmBuffer> buffer)

package/templates/xbox/src/platform/DecodeQueue.cpp

@@ -0,0 +1,136 @@
+#include "DecodeQueue.h"
+
+#ifdef _WIN32
+#include <objbase.h>
+#endif
+
+#include <algorithm>
+#include <condition_variable>
+#include <deque>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace next2d::decodequeue {
+
+namespace {
+
+struct Job {
+    std::function<void()> work;
+    std::function<void()> complete;
+};
+
+struct Queue {
+    std::mutex mutex;
+    std::condition_variable cv;
+    std::deque<Job> pending;                       // 未処理 (プールスレッドが取る)
+    std::deque<std::function<void()>> done;        // work 完了済み (Pump が実行)
+    std::vector<std::thread> threads;
+    bool stop = false;
+
+    void ThreadMain()
+    {
+#ifdef _WIN32
+        // WIC / Media Foundation は COM を要する。プールスレッド毎に MTA で初期化する
+        // (per-call 実装なので MTA スレッド間で共有状態は無い)。
+        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+        for (;;) {
+            Job job;
+            {
+                std::unique_lock<std::mutex> lock(mutex);
+                cv.wait(lock, [this] { return stop || !pending.empty(); });
+                if (stop) {
+                    break;
+                }
+                job = std::move(pending.front());
+                pending.pop_front();
+            }
+            if (job.work) {
+                job.work();
+            }
+            {
+                std::lock_guard<std::mutex> lock(mutex);
+                done.push_back(std::move(job.complete));
+            }
+        }
+#ifdef _WIN32
+        CoUninitialize();
+#endif
+    }
+
+    void EnsureThreads()
+    {
+        if (!threads.empty()) {
+            return;
+        }
+        // デコードは CPU バウンド。コア数の半分 (2〜4) で遷移時のバースト
+        // (画像数十枚 + BGM) を並列処理しつつ、メイン/GC スレッドを圧迫しない。
+        const unsigned hw = std::thread::hardware_concurrency();
+        const unsigned count = std::clamp(hw / 2u, 2u, 4u);
+        threads.reserve(count);
+        for (unsigned i = 0; i < count; ++i) {
+            threads.emplace_back([this] { ThreadMain(); });
+        }
+    }
+};
+
+Queue& Q()
+{
+    static Queue q;
+    return q;
+}
+
+} // namespace
+
+void Submit(std::function<void()> work, std::function<void()> complete)
+{
+    Queue& q = Q();
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        if (q.stop) {
+            return;   // Shutdown 後の Submit は破棄 (終了処理中のロード要求)
+        }
+        q.EnsureThreads();
+        q.pending.push_back({std::move(work), std::move(complete)});
+    }
+    q.cv.notify_one();
+}
+
+void Pump()
+{
+    Queue& q = Q();
+    std::deque<std::function<void()>> ready;
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        ready.swap(q.done);
+    }
+    for (auto& complete : ready) {
+        if (complete) {
+            complete();
+        }
+    }
+}
+
+void Shutdown()
+{
+    Queue& q = Q();
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        q.stop = true;
+    }
+    q.cv.notify_all();
+    for (auto& t : q.threads) {
+        if (t.joinable()) {
+            t.join();
+        }
+    }
+    q.threads.clear();
+    // 未実行の work / complete を破棄する。complete は v8::Global を捕捉して
+    // いるため、この関数は Isolate 破棄前に呼ばれる必要がある (main.cpp の後始末順)。
+    std::lock_guard<std::mutex> lock(q.mutex);
+    q.pending.clear();
+    q.done.clear();
+}
+
+} // namespace next2d::decodequeue

package/templates/xbox/src/platform/DecodeQueue.h

@@ -0,0 +1,27 @@
+// DecodeQueue: リソースデコード用のバックグラウンドスレッドプール。
+//
+// 画像 (WIC) / 音声 (Media Foundation) のデコードはメインスレッドで同期実行すると
+// 画面遷移時に 1 秒超のフレームヒッチになる (--perf 計測で特定)。work を
+// プールスレッドへ逃がし、complete をメインループの Pump() で実行することで
+// ヒッチを解消し、複数リソースの並列デコードでロード時間も短縮する。
+// スレッドは Xbox で許可されている (禁止は動的コード生成のみ)。
+//
+// 契約:
+//   - work    : プールスレッドで実行される。V8 / JS ヒープに触れてはならない。
+//               (WIC/MF は per-call 実装で COM はスレッド毎に MTA 初期化済み)
+//   - complete: work 完了後、メインスレッドの Pump() から実行される。V8 可。
+//               (v8::Global を捕捉してよい。Pump は isolate/コンテキストスコープ外で
+//                呼ばれるため、complete 側で HandleScope/Context::Scope を張ること)
+//   - Shutdown: 全スレッドを join し、未実行の work / complete を破棄する。
+//               捕捉された v8::Global の破棄があるため Isolate 破棄前に呼ぶこと。
+#pragma once
+
+#include <functional>
+
+namespace next2d::decodequeue {
+
+void Submit(std::function<void()> work, std::function<void()> complete);
+void Pump();
+void Shutdown();
+
+} // namespace next2d::decodequeue

package/templates/xbox/src/platform/ImageDecoder.cpp

@@ -0,0 +1,44 @@
+#include "ImageDecoder.h"
+
+// stb_image: public domain のヘッダオンリー画像デコーダ (third_party/)。
+// メモリ入力のみ使用するため stdio を切る。
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_STDIO
+#include "third_party/stb_image.h"
+
+#if defined(_WIN32) && !NEXT2D_XBOX_CONSOLE
+#include "WicDecoder.h"
+#endif
+
+#include <cstring>
+
+namespace next2d {
+
+bool DecodeImage(const std::vector<uint8_t>& input, DecodedImage& out)
+{
+    if (input.empty()) {
+        return false;
+    }
+
+    // 1) stb_image (PNG/JPEG/GIF/BMP/TGA/PSD)。コンソールでも動く共通経路。
+    int w = 0, h = 0, comp = 0;
+    stbi_uc* pixels = stbi_load_from_memory(
+        input.data(), static_cast<int>(input.size()), &w, &h, &comp, 4);
+    if (pixels) {
+        out.width  = static_cast<uint32_t>(w);
+        out.height = static_cast<uint32_t>(h);
+        out.rgba.assign(pixels, pixels + static_cast<size_t>(w) * h * 4);
+        stbi_image_free(pixels);
+        return true;
+    }
+
+#if defined(_WIN32) && !NEXT2D_XBOX_CONSOLE
+    // 2) デスクトップのみ: WIC フォールバック (TIFF/HEIF 等 stb 非対応形式の保険)。
+    //    コンソールには WIC が無いためこの経路はコンパイルされない。
+    return DecodeImageWithWIC(input, out);
+#else
+    return false;
+#endif
+}
+
+} // namespace next2d

package/templates/xbox/src/platform/ImageDecoder.h

@@ -0,0 +1,18 @@
+// 画像デコード (エンコード済みバイト列 -> RGBA8)。
+//
+// 第一候補は stb_image (PNG/JPEG/GIF/BMP、全プラットフォーム共通)。
+// コンソール (Game Core OS) には WIC が存在しないため、WIC 依存を第一経路から
+// 外すことで PC 検証と実機の挙動を一致させる。デスクトップのみ、stb が扱えない
+// 形式 (TIFF/HEIF 等) への保険として WIC フォールバックを残す。
+#pragma once
+
+#include "ImageTypes.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace next2d {
+
+bool DecodeImage(const std::vector<uint8_t>& input, DecodedImage& out);
+
+} // namespace next2d

package/templates/xbox/src/platform/StbTextRasterizer.cpp

@@ -0,0 +1,324 @@
+#include "StbTextRasterizer.h"
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_STATIC
+#include "third_party/stb_truetype.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstring>
+
+namespace next2d::stbtext {
+
+namespace {
+
+struct Font {
+    std::string name_lower;      // 登録名 (小文字)
+    bool bold = false;           // 名前に "bold" を含むか
+    std::vector<uint8_t> data;   // TTF/OTF 本体 (fontinfo が参照し続けるため保持)
+    stbtt_fontinfo info = {};
+};
+
+// 登録フォント。ゲーム起動時に main が登録し、以後は読み取りのみ
+// (worker も協調シングルスレッドなので排他は不要)。
+std::vector<Font>& Fonts()
+{
+    static std::vector<Font> fonts;
+    return fonts;
+}
+
+std::string ToLower(std::string s)
+{
+    std::transform(s.begin(), s.end(), s.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    return s;
+}
+
+// CSS font 文字列から px サイズ / bold / ファミリ名リストを取り出す。
+// 例: "bold 24px 'Noto Sans JP', sans-serif"
+struct CssFont {
+    double px = 16.0;
+    bool bold = false;
+    std::vector<std::string> families;   // 小文字・引用符除去済み
+};
+
+CssFont ParseCssFont(const std::string& css)
+{
+    CssFont out;
+    const std::string lower = ToLower(css);
+
+    if (lower.find("bold") != std::string::npos) {
+        out.bold = true;
+    } else {
+        // 数値ウェイト (600 以上を bold 扱い)。"NNNpx" と混同しないよう
+        // 独立トークンのみ見る。
+        size_t pos = 0;
+        while (pos < lower.size()) {
+            const size_t start = lower.find_first_not_of(" \t", pos);
+            if (start == std::string::npos) break;
+            size_t end = lower.find_first_of(" \t", start);
+            if (end == std::string::npos) end = lower.size();
+            const std::string token = lower.substr(start, end - start);
+            char* endp = nullptr;
+            const long w = std::strtol(token.c_str(), &endp, 10);
+            if (endp && *endp == '\0' && w >= 600 && w <= 1000) {
+                out.bold = true;
+            }
+            pos = end;
+        }
+    }
+
+    // "NNpx" (小数許容)
+    const size_t px_pos = lower.find("px");
+    if (px_pos != std::string::npos) {
+        size_t num_start = px_pos;
+        while (num_start > 0 &&
+               (std::isdigit(static_cast<unsigned char>(lower[num_start - 1])) ||
+                lower[num_start - 1] == '.')) {
+            --num_start;
+        }
+        if (num_start < px_pos) {
+            out.px = std::strtod(lower.substr(num_start, px_pos - num_start).c_str(), nullptr);
+        }
+        if (out.px <= 0) {
+            out.px = 16.0;
+        }
+
+        // px の後ろがファミリリスト (カンマ区切り、引用符除去)
+        size_t fam_start = lower.find_first_of(" \t", px_pos);
+        if (fam_start != std::string::npos) {
+            std::string families = lower.substr(fam_start + 1);
+            size_t pos = 0;
+            while (pos <= families.size()) {
+                size_t comma = families.find(',', pos);
+                if (comma == std::string::npos) comma = families.size();
+                std::string fam = families.substr(pos, comma - pos);
+                // trim + 引用符除去
+                const auto is_trim = [](char c) {
+                    return c == ' ' || c == '\t' || c == '\'' || c == '"';
+                };
+                while (!fam.empty() && is_trim(fam.front())) fam.erase(fam.begin());
+                while (!fam.empty() && is_trim(fam.back()))  fam.pop_back();
+                if (!fam.empty()) {
+                    out.families.push_back(fam);
+                }
+                pos = comma + 1;
+            }
+        }
+    }
+    return out;
+}
+
+// wstring -> Unicode コードポイント列。
+// Windows は wchar_t=UTF-16 (サロゲートペア復号)、他は UTF-32。
+std::vector<uint32_t> ToCodepoints(const std::wstring& text)
+{
+    std::vector<uint32_t> cps;
+    cps.reserve(text.size());
+    if (sizeof(wchar_t) == 2) {
+        for (size_t i = 0; i < text.size(); ++i) {
+            const uint32_t c = static_cast<uint16_t>(text[i]);
+            if (c >= 0xD800 && c <= 0xDBFF && i + 1 < text.size()) {
+                const uint32_t lo = static_cast<uint16_t>(text[i + 1]);
+                if (lo >= 0xDC00 && lo <= 0xDFFF) {
+                    cps.push_back(0x10000 + ((c - 0xD800) << 10) + (lo - 0xDC00));
+                    ++i;
+                    continue;
+                }
+            }
+            cps.push_back(c);
+        }
+    } else {
+        for (wchar_t c : text) {
+            cps.push_back(static_cast<uint32_t>(c));
+        }
+    }
+    return cps;
+}
+
+// css のファミリ指定と bold から最適な登録フォントを選ぶ。
+// 優先: ファミリ一致 + bold 一致 > ファミリ一致 > bold 一致 > 先頭。
+const Font* SelectFont(const CssFont& css)
+{
+    const auto& fonts = Fonts();
+    if (fonts.empty()) {
+        return nullptr;
+    }
+    const Font* family_match = nullptr;
+    for (const auto& fam : css.families) {
+        for (const auto& f : fonts) {
+            if (f.name_lower.find(fam) == std::string::npos &&
+                fam.find(f.name_lower) == std::string::npos) {
+                continue;
+            }
+            if (f.bold == css.bold) {
+                return &f;   // ファミリ+bold 完全一致
+            }
+            if (!family_match) {
+                family_match = &f;
+            }
+        }
+    }
+    if (family_match) {
+        return family_match;
+    }
+    for (const auto& f : fonts) {
+        if (f.bold == css.bold) {
+            return &f;
+        }
+    }
+    return &fonts.front();
+}
+
+// 計測とラスタライズで共有するレイアウト計算。
+struct Layout {
+    const Font* font = nullptr;
+    float scale = 0;
+    int ascent = 0, descent = 0;   // フォント単位
+    double width = 0;              // px
+    std::vector<uint32_t> cps;
+};
+
+bool ComputeLayout(const std::string& css_font, const std::wstring& text, Layout& lo)
+{
+    const CssFont css = ParseCssFont(css_font);
+    lo.font = SelectFont(css);
+    if (!lo.font) {
+        return false;
+    }
+    lo.scale = stbtt_ScaleForPixelHeight(&lo.font->info, static_cast<float>(css.px));
+    int line_gap = 0;
+    stbtt_GetFontVMetrics(&lo.font->info, &lo.ascent, &lo.descent, &line_gap);
+    lo.cps = ToCodepoints(text);
+
+    double x = 0;
+    for (size_t i = 0; i < lo.cps.size(); ++i) {
+        int advance = 0, lsb = 0;
+        stbtt_GetCodepointHMetrics(&lo.font->info, static_cast<int>(lo.cps[i]), &advance, &lsb);
+        x += advance * lo.scale;
+        if (i + 1 < lo.cps.size()) {
+            x += stbtt_GetCodepointKernAdvance(
+                     &lo.font->info,
+                     static_cast<int>(lo.cps[i]),
+                     static_cast<int>(lo.cps[i + 1])) * lo.scale;
+        }
+    }
+    lo.width = x;
+    return true;
+}
+
+} // namespace
+
+bool RegisterFont(const std::string& name, std::vector<uint8_t> data)
+{
+    if (data.empty()) {
+        return false;
+    }
+    Font font;
+    font.name_lower = ToLower(name);
+    font.bold = font.name_lower.find("bold") != std::string::npos;
+    font.data = std::move(data);
+    const int offset = stbtt_GetFontOffsetForIndex(font.data.data(), 0);
+    if (offset < 0 || !stbtt_InitFont(&font.info, font.data.data(), offset)) {
+        return false;
+    }
+    Fonts().push_back(std::move(font));
+    return true;
+}
+
+bool HasFonts()
+{
+    return !Fonts().empty();
+}
+
+bool MeasureText(const std::string& css_font, const std::wstring& text,
+                 TextMetricsInfo& out)
+{
+    Layout lo;
+    if (!ComputeLayout(css_font, text, lo)) {
+        return false;
+    }
+    out.width   = lo.width;
+    out.ascent  = lo.ascent * lo.scale;
+    out.descent = -lo.descent * lo.scale;   // stbtt の descent は負値
+    return true;
+}
+
+bool RasterizeText(const std::string& css_font, const std::wstring& text,
+                   uint8_t r, uint8_t g, uint8_t b, TextBitmap& out)
+{
+    if (text.empty()) {
+        return false;   // DirectWrite 実装と同じ契約 (空文字は false)
+    }
+    Layout lo;
+    if (!ComputeLayout(css_font, text, lo)) {
+        return false;
+    }
+
+    const double ascent_px  = lo.ascent * lo.scale;
+    const double descent_px = -lo.descent * lo.scale;
+    const int width  = std::max(1, static_cast<int>(std::ceil(lo.width)) + 2);
+    const int height = std::max(1, static_cast<int>(std::ceil(ascent_px + descent_px)) + 2);
+    const int baseline = static_cast<int>(std::ceil(ascent_px)) + 1;
+
+    // 8bit カバレッジへ全グリフを合成してから RGBA 化する
+    std::vector<uint8_t> coverage(static_cast<size_t>(width) * height, 0);
+    double pen_x = 1.0;
+    for (size_t i = 0; i < lo.cps.size(); ++i) {
+        const int cp = static_cast<int>(lo.cps[i]);
+        int advance = 0, lsb = 0;
+        stbtt_GetCodepointHMetrics(&lo.font->info, cp, &advance, &lsb);
+
+        int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+        const float shift_x =
+            static_cast<float>(pen_x + lsb * lo.scale - std::floor(pen_x + lsb * lo.scale));
+        stbtt_GetCodepointBitmapBoxSubpixel(
+            &lo.font->info, cp, lo.scale, lo.scale, shift_x, 0, &x0, &y0, &x1, &y1);
+
+        const int gw = x1 - x0;
+        const int gh = y1 - y0;
+        if (gw > 0 && gh > 0) {
+            std::vector<uint8_t> glyph(static_cast<size_t>(gw) * gh);
+            stbtt_MakeCodepointBitmapSubpixel(
+                &lo.font->info, glyph.data(), gw, gh, gw,
+                lo.scale, lo.scale, shift_x, 0, cp);
+
+            const int dst_x = static_cast<int>(std::floor(pen_x + lsb * lo.scale));
+            const int dst_y = baseline + y0;
+            for (int yy = 0; yy < gh; ++yy) {
+                const int py = dst_y + yy;
+                if (py < 0 || py >= height) continue;
+                for (int xx = 0; xx < gw; ++xx) {
+                    const int px = dst_x + xx;
+                    if (px < 0 || px >= width) continue;
+                    uint8_t& dst = coverage[static_cast<size_t>(py) * width + px];
+                    dst = std::max(dst, glyph[static_cast<size_t>(yy) * gw + xx]);
+                }
+            }
+        }
+
+        pen_x += advance * lo.scale;
+        if (i + 1 < lo.cps.size()) {
+            pen_x += stbtt_GetCodepointKernAdvance(
+                         &lo.font->info, cp, static_cast<int>(lo.cps[i + 1])) * lo.scale;
+        }
+    }
+
+    out.width = width;
+    out.height = height;
+    out.baseline = baseline;
+    out.rgba.assign(static_cast<size_t>(width) * height * 4, 0);
+    for (size_t i = 0; i < coverage.size(); ++i) {
+        const uint8_t a = coverage[i];
+        if (!a) continue;
+        uint8_t* dst = &out.rgba[i * 4];
+        dst[0] = r;
+        dst[1] = g;
+        dst[2] = b;
+        dst[3] = a;   // straight alpha (TextBitmap の契約)
+    }
+    return true;
+}
+
+} // namespace next2d::stbtext

package/templates/xbox/src/platform/StbTextRasterizer.h

@@ -0,0 +1,37 @@
+// stb_truetype によるテキスト計測/ラスタライズ (全プラットフォーム共通)。
+//
+// コンソール (Game Core OS) には DirectWrite が無いため、TextRasterizer.cpp の
+// コンソール分岐がこの実装へ委譲する (デスクトップは従来どおり DirectWrite)。
+// システムフォントにも依存できないため、フォントは実行時に登録する:
+//   - 埋め込み pak 内の *.ttf/*.otf (ゲーム資材。main.cpp が起動時に登録)
+//   - exe 隣接の fonts/*.ttf (開発ビルド用)
+// フォント未登録の場合は false を返し、呼び出し側 (Canvas2D) が近似値へ
+// フォールバックする (TextRasterizer.h と同じ契約)。
+//
+// 制限 (DirectWrite との差): 合字/シェーピング無し (CJK は影響なし)、
+// bold は登録フォントに bold バリアントがある場合のみ反映。
+#pragma once
+
+#include "TextRasterizer.h"   // TextBitmap / TextMetricsInfo
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace next2d::stbtext {
+
+// TTF/OTF バイト列をフォントとして登録する (name はファイル名 stem 等の識別子。
+// "bold" を含む名前は bold バリアントとして扱う)。不正なフォントは false。
+bool RegisterFont(const std::string& name, std::vector<uint8_t> data);
+
+// 登録済みフォントが 1 つ以上あるか。
+bool HasFonts();
+
+// css_font 例: "bold 24px Arial", "16px 'Noto Sans JP', sans-serif"
+bool MeasureText(const std::string& css_font, const std::wstring& text,
+                 TextMetricsInfo& out);
+
+bool RasterizeText(const std::string& css_font, const std::wstring& text,
+                   uint8_t r, uint8_t g, uint8_t b, TextBitmap& out);
+
+} // namespace next2d::stbtext