@next2d/builder 0.1.7 → 0.1.10

package/templates/xbox/src/AssetLoader.cpp

@@ -1,4 +1,5 @@
 #include "AssetLoader.h"
+#include "EmbeddedAssets.h"
 
 #include <filesystem>
 #include <fstream>
@@ -14,9 +15,10 @@ AssetLoader::AssetLoader(std::string root)
 {
 }
 
-std::string AssetLoader::Resolve(const std::string& url) const
+std::string AssetLoader::RelativeKey(const std::string& url) const
 {
-    // 先頭の "/" や "./"、絶対 URL のオリジンを剥がして assets/app 基準に寄せる。
+    // 先頭の "/" や "./"、絶対 URL のオリジンを剥がして assets/app 基準の相対パスにする。
+    // 埋め込み pak のキー(フォワードスラッシュ相対)と一致させるためのもの。
     std::string path = url;
 
     // スキーム付き (file://, http://localhost/...) はパス部だけ取り出す
@@ -39,11 +41,101 @@ std::string AssetLoader::Resolve(const std::string& url) const
         path = path.substr(2);
     }
 
-    return (fs::path(root_) / path).string();
+    // バックスラッシュはフォワードスラッシュへ正規化 (pak キーと一致させる)。
+    for (char& c : path) {
+        if (c == '\\') c = '/';
+    }
+    return path;
+}
+
+std::string AssetLoader::Resolve(const std::string& url) const
+{
+    return (fs::path(root_) / RelativeKey(url)).string();
+}
+
+// base64 デコード (data: URI 用)。Image.cpp の同等実装と同じ仕様。
+static bool DecodeBase64(const std::string& in, std::vector<uint8_t>* out)
+{
+    auto val = [](char c) -> int {
+        if (c >= 'A' && c <= 'Z') return c - 'A';
+        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+        if (c >= '0' && c <= '9') return c - '0' + 52;
+        if (c == '+') return 62;
+        if (c == '/') return 63;
+        return -1;
+    };
+    out->clear();
+    out->reserve(in.size() / 4 * 3);
+    int buf = 0, bits = 0;
+    for (char c : in) {
+        if (c == '=' || c == '\r' || c == '\n' || c == ' ') continue;
+        const int v = val(c);
+        if (v < 0) return false;
+        buf = buf << 6 | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out->push_back(static_cast<uint8_t>(buf >> bits & 0xFF));
+        }
+    }
+    return true;
+}
+
+// data: URI を「%xx」percent-decode する (base64 でない稀なケース用)。
+static std::vector<uint8_t> PercentDecode(const std::string& in)
+{
+    std::vector<uint8_t> out;
+    out.reserve(in.size());
+    auto hex = [](char c) -> int {
+        if (c >= '0' && c <= '9') return c - '0';
+        if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+        if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+        return -1;
+    };
+    for (size_t i = 0; i < in.size(); ++i) {
+        if (in[i] == '%' && i + 2 < in.size()) {
+            const int hi = hex(in[i + 1]);
+            const int lo = hex(in[i + 2]);
+            if (hi >= 0 && lo >= 0) {
+                out.push_back(static_cast<uint8_t>(hi << 4 | lo));
+                i += 2;
+                continue;
+            }
+        }
+        out.push_back(static_cast<uint8_t>(in[i]));
+    }
+    return out;
 }
 
 std::optional<std::vector<uint8_t>> AssetLoader::ReadBinary(const std::string& url) const
 {
+    // data: URI (Vite の ?inline はアセットを data:<mime>;base64,<payload> に埋め込む)。
+    // このゲームは全サウンドを ?inline で取り込むため実体は data URI。画像は Image.cpp が
+    // 対応済みだが、音声 (new Audio / Sound の XHR fetch) もこの ReadBinary を通るので
+    // ここで一括デコードする。未対応だと data: をファイルパス扱いして開けず、全 SFX/BGM が
+    // 無音になる (XAudio2 の可否とは無関係に実機でも無音)。
+    if (url.rfind("data:", 0) == 0) {
+        const auto comma = url.find(',');
+        if (comma == std::string::npos) {
+            return std::nullopt;
+        }
+        const std::string meta = url.substr(5, comma - 5);  // 例: "audio/mpeg;base64"
+        const std::string payload = url.substr(comma + 1);
+        if (meta.find("base64") != std::string::npos) {
+            std::vector<uint8_t> out;
+            if (!DecodeBase64(payload, &out)) {
+                return std::nullopt;
+            }
+            return out;
+        }
+        return PercentDecode(payload);
+    }
+
+    // 埋め込みモード優先: exe 内 pak に同じ相対キーがあれば実ファイルより先に返す。
+    if (const auto* embedded = GetEmbeddedAsset(RelativeKey(url))) {
+        return *embedded;
+    }
+
     const std::string path = Resolve(url);
     std::ifstream ifs(path, std::ios::binary | std::ios::ate);
     if (!ifs) {
@@ -61,6 +153,10 @@ std::optional<std::vector<uint8_t>> AssetLoader::ReadBinary(const std::string& u
 
 std::optional<std::string> AssetLoader::ReadText(const std::string& url) const
 {
+    if (const auto* embedded = GetEmbeddedAsset(RelativeKey(url))) {
+        return std::string(embedded->begin(), embedded->end());
+    }
+
     const std::string path = Resolve(url);
     std::ifstream ifs(path, std::ios::binary);
     if (!ifs) {
@@ -74,22 +170,29 @@ std::optional<std::string> AssetLoader::ReadText(const std::string& url) const
 std::optional<std::string> AssetLoader::ResolveEntryModule() const
 {
     // vite が出力する index.html から <script type="module" src="..."> を抽出する。
-    const fs::path index = fs::path(root_) / "index.html";
-    std::ifstream ifs(index, std::ios::binary);
-    if (!ifs) {
-        return std::nullopt;
+    // 埋め込みモードでは pak から、無ければ実ファイルから読む。
+    std::string html;
+    if (const auto* embedded = GetEmbeddedAsset("index.html")) {
+        html.assign(embedded->begin(), embedded->end());
+    } else {
+        const fs::path index = fs::path(root_) / "index.html";
+        std::ifstream ifs(index, std::ios::binary);
+        if (!ifs) {
+            return std::nullopt;
+        }
+        std::ostringstream oss;
+        oss << ifs.rdbuf();
+        html = oss.str();
     }
-    std::ostringstream oss;
-    oss << ifs.rdbuf();
-    const std::string html = oss.str();
 
     // type="module" を含む <script ... src="..."> を優先して拾う。
+    // 返す値は assets/app 基準の絶対パス。モジュールローダ側で埋め込み/実ファイルを解決する。
     std::regex module_re(
         R"(<script[^>]*type=["']module["'][^>]*src=["']([^"']+)["'])",
         std::regex::icase);
     std::smatch m;
     if (std::regex_search(html, m, module_re)) {
-        return (fs::path(root_) / Resolve(m[1].str()).substr(root_.size() + 1)).string();
+        return Resolve(m[1].str());
     }
 
     // 逆順 (src が先) も試す
@@ -97,7 +200,7 @@ std::optional<std::string> AssetLoader::ResolveEntryModule() const
         R"(<script[^>]*src=["']([^"']+)["'][^>]*type=["']module["'])",
         std::regex::icase);
     if (std::regex_search(html, m, module_re2)) {
-        return (fs::path(root_) / Resolve(m[1].str()).substr(root_.size() + 1)).string();
+        return Resolve(m[1].str());
     }
 
     return std::nullopt;

package/templates/xbox/src/AssetLoader.h

@@ -20,6 +20,10 @@ public:
     // 相対 URL/パスを assets/app 基準の絶対パスへ解決する。
     std::string Resolve(const std::string& url) const;
 
+    // URL を assets/app 基準の相対キー(フォワードスラッシュ)へ正規化する。
+    // 埋め込み pak のキーと一致させるために使う。
+    std::string RelativeKey(const std::string& url) const;
+
     // バイナリ読み込み。存在しなければ nullopt。
     std::optional<std::vector<uint8_t>> ReadBinary(const std::string& url) const;
 

package/templates/xbox/src/EmbeddedAssets.cpp

@@ -0,0 +1,149 @@
+#include "EmbeddedAssets.h"
+
+#include <filesystem>
+#include <map>
+#include <utility>
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <Windows.h>
+#endif
+
+namespace fs = std::filesystem;
+
+namespace next2d {
+
+namespace {
+
+std::map<std::string, std::vector<uint8_t>> g_assets;
+std::string g_root;   // assets/app の正規化済み絶対パス
+bool g_loaded = false;
+bool g_has = false;
+
+inline uint32_t Read32LE(const uint8_t* p)
+{
+    return static_cast<uint32_t>(p[0])
+         | static_cast<uint32_t>(p[1]) << 8
+         | static_cast<uint32_t>(p[2]) << 16
+         | static_cast<uint32_t>(p[3]) << 24;
+}
+
+} // namespace
+
+bool ParseEmbeddedPak(const uint8_t* data, std::size_t size,
+                      std::vector<std::pair<std::string, std::vector<uint8_t>>>* out)
+{
+    if (!data || size < 12) {
+        return false;
+    }
+    if (data[0] != 'N' || data[1] != '2' || data[2] != 'D' || data[3] != 'A') {
+        return false;
+    }
+    // data[4..7] = version (現状 1 のみ。将来の互換のため値は検査しない)
+    const uint32_t count = Read32LE(data + 8);
+    std::size_t off = 12;
+    for (uint32_t i = 0; i < count; ++i) {
+        if (off + 4 > size) return false;
+        const uint32_t key_len = Read32LE(data + off);
+        off += 4;
+        if (key_len > size || off + key_len > size) return false;
+        std::string key(reinterpret_cast<const char*>(data + off), key_len);
+        off += key_len;
+
+        if (off + 4 > size) return false;
+        const uint32_t data_len = Read32LE(data + off);
+        off += 4;
+        if (data_len > size || off + data_len > size) return false;
+        std::vector<uint8_t> bytes(data + off, data + off + data_len);
+        off += data_len;
+
+        if (out) {
+            out->emplace_back(std::move(key), std::move(bytes));
+        }
+    }
+    return true;
+}
+
+bool InitEmbeddedAssets()
+{
+    if (g_loaded) {
+        return g_has;
+    }
+    g_loaded = true;
+
+#ifdef _WIN32
+    // 実行ファイル自身のリソースから "N2DASSETS" (RCDATA) を取り出す。
+    HRSRC res = FindResourceW(nullptr, L"N2DASSETS", RT_RCDATA);
+    if (res) {
+        HGLOBAL handle = LoadResource(nullptr, res);
+        const DWORD sz = SizeofResource(nullptr, res);
+        const void* ptr = handle ? LockResource(handle) : nullptr;
+        if (ptr && sz >= 12) {
+            std::vector<std::pair<std::string, std::vector<uint8_t>>> entries;
+            if (ParseEmbeddedPak(static_cast<const uint8_t*>(ptr), sz, &entries)) {
+                for (auto& e : entries) {
+                    g_assets.emplace(std::move(e.first), std::move(e.second));
+                }
+                g_has = true;
+            }
+        }
+    }
+#endif
+
+    return g_has;
+}
+
+bool HasEmbeddedAssets()
+{
+    return g_has;
+}
+
+void SetEmbeddedAssetsRoot(const std::string& abs_root)
+{
+    std::error_code ec;
+    fs::path canon = fs::weakly_canonical(fs::path(abs_root), ec);
+    g_root = ec ? abs_root : canon.string();
+}
+
+const std::vector<uint8_t>* GetEmbeddedAsset(const std::string& key)
+{
+    if (!g_has) {
+        return nullptr;
+    }
+    auto it = g_assets.find(key);
+    return it == g_assets.end() ? nullptr : &it->second;
+}
+
+void ForEachEmbeddedAsset(
+    const std::function<void(const std::string& key,
+                             const std::vector<uint8_t>& data)>& callback)
+{
+    if (!g_has) {
+        return;
+    }
+    for (const auto& [key, data] : g_assets) {
+        callback(key, data);
+    }
+}
+
+const std::vector<uint8_t>* GetEmbeddedAssetByAbsPath(const std::string& abs)
+{
+    if (!g_has || g_root.empty()) {
+        return nullptr;
+    }
+    // 純粋に字句的な相対化 (FS 参照なし)。abs も root も weakly_canonical 済みを前提。
+    const fs::path rel = fs::path(abs).lexically_relative(fs::path(g_root));
+    if (rel.empty()) {
+        return nullptr;
+    }
+    const std::string key = rel.generic_string();
+    // root 外 ("../..") は埋め込み対象外。
+    if (key.rfind("..", 0) == 0) {
+        return nullptr;
+    }
+    return GetEmbeddedAsset(key);
+}
+
+} // namespace next2d

package/templates/xbox/src/EmbeddedAssets.h

@@ -0,0 +1,60 @@
+// EmbeddedAssets: exe に埋め込んだ assets pak (Windows RCDATA) を解析して提供する。
+//
+// 目的: 書き出した *.exe の隣に平文の JS/HTML を置かず、ゲーム資産(assets/app 一式 +
+// js/bootstrap.js)を exe 内リソースへ格納する。埋め込みが無い(開発ビルド等)場合は
+// 全 API が「見つからない」を返し、呼び出し側はファイルシステムへフォールバックする。
+// これにより埋め込みは純粋に加算的で、既存のファイル読み経路を壊さない。
+//
+// pak フォーマット (リトルエンディアン uint32):
+//   [4]  magic "N2DA"
+//   [4]  uint32 version (=1)
+//   [4]  uint32 count
+//   count 回:
+//     [4]         uint32 key_len
+//     [key_len]   key   (UTF-8, フォワードスラッシュ相対パス)
+//     [4]         uint32 data_len
+//     [data_len]  data
+//
+// key は次のいずれか:
+//   - assets/app 基準の相対パス (例 "app.js", "index.html", "assets/xxx.js")
+//   - "js/bootstrap.js" / "js/selftest.js" (exe_dir 基準)
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace next2d {
+
+// exe リソースから pak をロードして解析する (プロセスで一度だけ)。
+// 埋め込みが存在し解析に成功したとき true。以後の Has/Get はこの結果に従う。
+bool InitEmbeddedAssets();
+
+// 埋め込みが利用可能か。
+bool HasEmbeddedAssets();
+
+// assets/app のルート絶対パスを登録する。GetEmbeddedAssetByAbsPath の
+// 相対キー算出に使う。main で AssetLoader の root と同じ値を渡す。
+void SetEmbeddedAssetsRoot(const std::string& abs_root);
+
+// 相対キー直接指定で検索する。見つかればバイト列ポインタ(プロセス生存中有効)、無ければ nullptr。
+const std::vector<uint8_t>* GetEmbeddedAsset(const std::string& key);
+
+// 全エントリを列挙する (フォント等、キーが事前に分からない資材の収集用)。
+// callback には key とデータ (プロセス生存中有効) が渡る。
+void ForEachEmbeddedAsset(
+    const std::function<void(const std::string& key,
+                             const std::vector<uint8_t>& data)>& callback);
+
+// モジュールローダ用: assets/app 配下の絶対パスを相対キーへ変換して検索する。
+// root 未登録 / abs が root 配下でない場合は nullptr。
+const std::vector<uint8_t>* GetEmbeddedAssetByAbsPath(const std::string& abs);
+
+// テスト用: 生の pak バッファを解析して (key -> data) を out へ格納する。
+// プラットフォーム非依存で macOS 上でも検証できる。成功時 true。
+bool ParseEmbeddedPak(const uint8_t* data, std::size_t size,
+                      std::vector<std::pair<std::string, std::vector<uint8_t>>>* out);
+
+} // namespace next2d

package/templates/xbox/src/EventLoop.cpp

@@ -63,6 +63,7 @@ void EventLoop::ClearTimer(uint32_t id)
 uint32_t EventLoop::RequestAnimationFrame(v8::Local<v8::Function> callback)
 {
     const uint32_t id = next_raf_id_++;
+
     v8::Global<v8::Function> global;
     global.Reset(isolate_, callback);
     raf_callbacks_.emplace_back(id, std::move(global));
@@ -71,6 +72,16 @@ uint32_t EventLoop::RequestAnimationFrame(v8::Local<v8::Function> callback)
 
 void EventLoop::CancelAnimationFrame(uint32_t id)
 {
+    // 未実行分は即座に取り除く。raf_cancelled_ だけに頼ると、RunAnimationFrame の
+    // 実行中に登録されたコールバックへのキャンセルが同フレーム末尾の clear で失われ、
+    // キャンセル済みのはずの rAF が翌フレームに実行されてしまう (ticker/Tween の多重化)。
+    for (auto it = raf_callbacks_.begin(); it != raf_callbacks_.end(); ++it) {
+        if (it->first == id) {
+            raf_callbacks_.erase(it);
+            return;
+        }
+    }
+    // 実行中バッチ (RunAnimationFrame の current) 内のものはフラグで無効化する
     raf_cancelled_.push_back(id);
 }
 
@@ -104,7 +115,7 @@ void EventLoop::PumpTimers()
 
         v8::TryCatch try_catch(isolate_);
         (void) fn->Call(ctx, global, 0, nullptr);
-        // 例外はコンソールに委譲 (V8Runtime のメッセージハンドラが拾う)
+        v8util::ReportCaught(isolate_, &try_catch, "setTimeout/setInterval callback");
 
         if (!it->second.repeat) {
             // 単発は実行後に破棄
@@ -149,6 +160,7 @@ void EventLoop::RunAnimationFrame(double timestamp_ms)
         v8::TryCatch try_catch(isolate_);
         v8::Local<v8::Value> args[1] = { arg };
         (void) fn->Call(ctx, global, 1, args);
+        v8util::ReportCaught(isolate_, &try_catch, "requestAnimationFrame callback");
     }
 
     raf_cancelled_.clear();

package/templates/xbox/src/EventLoop.h

@@ -50,6 +50,18 @@ public:
     // 保留タスクが残っているか (終了判定用)
     bool HasPendingWork() const;
 
+    // 診断用: 登録中の rAF コールバック数 / タイマー数
+    size_t PendingAnimationFrameCount() const { return raf_callbacks_.size(); }
+    size_t PendingTimerCount() const { return timers_.size(); }
+
+    // 全タイマー/rAF コールバック (v8::Global) を解放する。Isolate::Dispose より
+    // 前に必ず呼ぶこと (スタック巻き戻しでの破棄は Isolate 破棄後になり fail-fast)。
+    void Shutdown() {
+        timers_.clear();
+        raf_callbacks_.clear();
+        raf_cancelled_.clear();
+    }
+
 private:
     struct TimerEntry {
         v8::Global<v8::Function> callback;