@next2d/builder 0.1.8 → 0.1.10

package/templates/xbox/src/bindings/RasterCore.h

@@ -7,6 +7,7 @@
 #include <cctype>
 #include <cmath>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -26,10 +27,18 @@ struct SubPath {
 
 struct RGBA { uint8_t r=0,g=0,b=0,a=255; };
 
-// クリップ矩形 (デバイス座標, [x0,x1) x [y0,y1))。active=false なら無制限。
+// クリップ領域 (デバイス座標)。
+//   active=false          … 無制限
+//   active=true, mask=null … 矩形クリップ [x0,x1) x [y0,y1) (厳密)
+//   mask!=null            … 任意形状クリップ。x0..y1 は外接矩形 (高速リジェクト用)、
+//                            mask は surface と同寸のカバレッジ (1=内側/0=外側)。
+// mask は shared_ptr のため save()/restore() の state コピーで安価に共有される
+// (clip() は既存 mask を破壊せず新しい mask を割り当てるので復元が壊れない)。
 struct ClipRect {
     bool   active = false;
     double x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+    std::shared_ptr<const std::vector<uint8_t>> mask;
+    int mask_w = 0, mask_h = 0;
 };
 
 // RGBA8 のピクセルバッファ。
@@ -101,6 +110,9 @@ inline void Blend(Surface& s, const ClipRect& clip, int x, int y, const RGBA& co
 {
     if (x < 0 || y < 0 || x >= s.width || y >= s.height) return;
     if (clip.active && (x < clip.x0 || x >= clip.x1 || y < clip.y0 || y >= clip.y1)) return;
+    // 任意形状クリップ: マスクの外なら書き込まない。
+    if (clip.mask && (x >= clip.mask_w || y >= clip.mask_h ||
+                      (*clip.mask)[static_cast<size_t>(y) * clip.mask_w + x] == 0)) return;
     size_t i = (static_cast<size_t>(y) * s.width + x) * 4;
     double a = (col.a / 255.0) * alpha;
     s.pixels[i+0] = static_cast<uint8_t>(col.r * a + s.pixels[i+0] * (1 - a));
@@ -215,6 +227,98 @@ inline void IntersectClip(ClipRect& clip, double nx0, double ny0, double nx1, do
     }
 }
 
+// パスが単一の軸並行矩形か判定する (矩形なら外接矩形クリップで厳密に足りる)。
+// beginPath→rect() は 4 or 5 点 (閉路点重複) の矩形サブパスになる。
+inline bool IsAxisAlignedRect(const std::vector<SubPath>& path)
+{
+    if (path.size() != 1) return false;
+    const std::vector<Point>& p = path[0].pts;
+    // 末尾が始点と重複する 5 点表現も許容する
+    size_t n = p.size();
+    if (n == 5 && std::abs(p[4].x - p[0].x) < 1e-6 && std::abs(p[4].y - p[0].y) < 1e-6) {
+        n = 4;
+    }
+    if (n != 4) return false;
+    // 各辺が水平または垂直であること
+    for (size_t i = 0; i < 4; ++i) {
+        const Point& a = p[i];
+        const Point& b = p[(i + 1) % 4];
+        const bool horizontal = std::abs(a.y - b.y) < 1e-6;
+        const bool vertical   = std::abs(a.x - b.x) < 1e-6;
+        if (!horizontal && !vertical) return false;
+    }
+    return true;
+}
+
+// パスを nonzero winding でカバレッジマスク (surface 同寸, 1=内側) にラスタライズする。
+// スキャンライン規約は FillPath と一致させる (塗りと同じ形にクリップされる)。
+inline std::shared_ptr<std::vector<uint8_t>> RasterizePathMask(
+    const std::vector<SubPath>& path, int width, int height)
+{
+    auto mask = std::make_shared<std::vector<uint8_t>>(
+        static_cast<size_t>(width) * height, 0);
+    if (width <= 0 || height <= 0) return mask;
+
+    double miny = 1e18, maxy = -1e18;
+    for (auto& sp : path) for (auto& p : sp.pts) { miny = std::min(miny,p.y); maxy = std::max(maxy,p.y); }
+    if (maxy < miny) return mask;
+    int y0 = std::max(0, static_cast<int>(std::floor(miny)));
+    int y1 = std::min(height - 1, static_cast<int>(std::ceil(maxy)));
+    for (int y = y0; y <= y1; ++y) {
+        double sy = y + 0.5;
+        std::vector<std::pair<double,int>> xs;
+        for (auto& sp : path) {
+            size_t n = sp.pts.size();
+            if (n < 2) continue;
+            for (size_t i = 0; i < n; ++i) {
+                Point a = sp.pts[i];
+                Point b = sp.pts[(i+1) % n];
+                if ((a.y <= sy && b.y > sy) || (b.y <= sy && a.y > sy)) {
+                    double t = (sy - a.y) / (b.y - a.y);
+                    xs.push_back({a.x + t * (b.x - a.x), a.y < b.y ? 1 : -1});
+                }
+            }
+        }
+        std::sort(xs.begin(), xs.end());
+        int wind = 0;
+        for (size_t i = 0; i + 1 < xs.size(); ++i) {
+            wind += xs[i].second;
+            if (wind != 0) {
+                int xa = std::max(0, static_cast<int>(std::floor(xs[i].first)));
+                int xb = std::min(width - 1, static_cast<int>(std::ceil(xs[i+1].first)));
+                for (int x = xa; x <= xb; ++x) {
+                    (*mask)[static_cast<size_t>(y) * width + x] = 1;
+                }
+            }
+        }
+    }
+    return mask;
+}
+
+// 任意形状パスをクリップへ積集合で反映する (非矩形 clip() の実体)。
+// 外接矩形 (高速リジェクト) も同時に反映し、既存 mask があれば AND を取って
+// 新しい mask を割り当てる (save/restore 安全)。
+inline void IntersectClipMask(ClipRect& clip, const std::vector<SubPath>& path,
+                              int width, int height)
+{
+    double minx, miny, maxx, maxy;
+    if (PathBounds(path, &minx, &miny, &maxx, &maxy)) {
+        IntersectClip(clip, std::floor(minx), std::floor(miny),
+                      std::ceil(maxx), std::ceil(maxy));
+    }
+    auto next = RasterizePathMask(path, width, height);
+    if (clip.mask) {
+        const std::vector<uint8_t>& prev = *clip.mask;
+        const size_t n = std::min(next->size(), prev.size());
+        for (size_t i = 0; i < n; ++i) {
+            if (prev[i] == 0) { (*next)[i] = 0; }
+        }
+    }
+    clip.mask = next;
+    clip.mask_w = width;
+    clip.mask_h = height;
+}
+
 // 3次ベジェを現在サブパスへフラット化して追記する。p0 は変換済みの直前点。
 inline void FlattenCubic(std::vector<Point>& out,
                          Point p0, Point p1, Point p2, Point p3, int steps = 16)

package/templates/xbox/src/bindings/Video.cpp

@@ -15,15 +15,20 @@
 #include "v8/V8Util.h"
 #include "v8/WeakHandle.h"
 
+#include <string>
+#include <vector>
+
+// Media Foundation はコンソール (Game Core OS) に無いデスクトップ専用 API。
+// コンソールでは動画デコード未対応 (末尾の «CONSOLE» スタブ)。
+// 実機での動画対応は devkit 段階の課題。
+#if !NEXT2D_XBOX_CONSOLE
+
 #include <mfapi.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <shlwapi.h>
 #include <wrl/client.h>
 
-#include <string>
-#include <vector>
-
 #pragma comment(lib, "mfplat.lib")
 #pragma comment(lib, "mfreadwrite.lib")
 #pragma comment(lib, "mfuuid.lib")
@@ -322,3 +327,52 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+// «CONSOLE» 動画デコード未対応スタブ。
+// createElement('video') がクラッシュしないよう API 形状だけ提供する
+// (フレーム取得は常に false、canPlayType は空 = 非対応を正しく通知)。
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+
+bool GetVideoFramePixels(v8::Isolate*, v8::Local<v8::Object>,
+                         const uint8_t** out_rgba, uint32_t* out_width, uint32_t* out_height)
+{
+    *out_rgba = nullptr;
+    *out_width = 0;
+    *out_height = 0;
+    return false;
+}
+
+v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*host*/)
+{
+    v8::Local<v8::Object> self = v8::Object::New(isolate);
+    SetValue(isolate, self, "__isVideoElement", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "tagName", Str(isolate, "VIDEO"));
+    SetValue(isolate, self, "localName", Str(isolate, "video"));
+    SetValue(isolate, self, "videoWidth", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "videoHeight", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "paused", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "ended", v8::Boolean::New(isolate, false));
+    InstallEventTarget(isolate, self);
+    SetMethod(isolate, self, "load", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, self, "play", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
+        auto r = v8::Promise::Resolver::New(iso->GetCurrentContext()).ToLocalChecked();
+        r->Resolve(iso->GetCurrentContext(), v8::Undefined(iso)).Check();
+        a.GetReturnValue().Set(r->GetPromise());
+    });
+    SetMethod(isolate, self, "pause", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, self, "canPlayType", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        a.GetReturnValue().Set(Str(a.GetIsolate(), ""));
+    });
+    return self;
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE

package/templates/xbox/src/bindings/webgpu/WebGPU.cpp

@@ -8,6 +8,8 @@
 #include "gpu/DawnContext.h"
 #include "bindings/ImageSource.h"
 
+#include "v8/V8Util.h"
+
 #include <cstring>
 #include <iostream>
 #include <map>
@@ -1211,9 +1213,13 @@ static void Device_CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Valu
     v8::Local<v8::Object> d = args[0].As<v8::Object>();
 
     std::vector<wgpu::BindGroupLayoutEntry> entries;
+    // externalTexture の nextInChain 構造体は CreateBindGroupLayout 完了まで生存が必要。
+    // reserve でベクタ再割当を防ぎ、back() のアドレスを安定させる。
+    std::vector<wgpu::ExternalTextureBindingLayout> ext_layouts;
     v8::Local<v8::Value> ev = Prop(isolate, d, "entries");
     if (ev->IsArray()) {
         auto arr = ev.As<v8::Array>();
+        ext_layouts.reserve(arr->Length());
         for (uint32_t i = 0; i < arr->Length(); ++i) {
             v8::Local<v8::Value> v;
             if (!arr->Get(ctx, i).ToLocal(&v) || !v->IsObject()) continue;
@@ -1237,8 +1243,21 @@ static void Device_CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Valu
                     ? ToTextureViewDimension(webgpu::Str(isolate, t, "viewDimension"))
                     : wgpu::TextureViewDimension::e2D;
                 entry.texture.multisampled = Bool(isolate, t, "multisampled", false);
+            } else if (HasProp(isolate, o, "storageTexture")) {
+                auto st = Prop(isolate, o, "storageTexture").As<v8::Object>();
+                entry.storageTexture.access = HasProp(isolate, st, "access")
+                    ? ToStorageTextureAccess(webgpu::Str(isolate, st, "access"))
+                    : wgpu::StorageTextureAccess::WriteOnly;
+                entry.storageTexture.format = ToTextureFormat(webgpu::Str(isolate, st, "format"));
+                entry.storageTexture.viewDimension = HasProp(isolate, st, "viewDimension")
+                    ? ToTextureViewDimension(webgpu::Str(isolate, st, "viewDimension"))
+                    : wgpu::TextureViewDimension::e2D;
+            } else if (HasProp(isolate, o, "externalTexture")) {
+                // GPUExternalTextureBindingLayout は空 (メンバ無し)。sType は
+                // Dawn の C++ ラッパが既定で設定するため emplace してチェーンするだけでよい。
+                ext_layouts.emplace_back();
+                entry.nextInChain = &ext_layouts.back();
             }
-            // «EXTEND» storageTexture / externalTexture は必要に応じて追加
             entries.push_back(entry);
         }
     }
@@ -1347,6 +1366,11 @@ struct RenderPipelineScratch {
     // ConstantEntry.key が指すため CreateRenderPipeline 完了まで生存させる。
     std::vector<std::string> vs_const_keys, fs_const_keys;
     std::vector<wgpu::ConstantEntry> vs_constants, fs_constants;
+    // desc.depthStencil / desc.fragment はこれらのアドレスを指す。ディスクリプタ構築を
+    // ヘルパに切り出したため、ローカルだとヘルパ return でダングリング化する。scratch に
+    // 保持して CreateRenderPipeline[Async] が同期コピーするまで生存させる。
+    wgpu::DepthStencilState depth = {};
+    wgpu::FragmentState fragment = {};
 };
 
 // { "KEY": number|bool, ... } を wgpu::ConstantEntry 配列へ変換する。
@@ -1472,7 +1496,8 @@ static void FillRenderPipelineDescriptor(v8::Isolate* isolate, v8::Local<v8::Obj
     }
 
     // depthStencil (マスク処理は stencil8 + stencilFront/Back を使う)
-    wgpu::DepthStencilState depth = {};
+    // scratch.depth を参照 (アドレスを desc.depthStencil に格納するため寿命を延ばす)。
+    wgpu::DepthStencilState& depth = scratch.depth;
     v8::Local<v8::Value> dsv = Prop(isolate, d, "depthStencil");
     if (dsv->IsObject()) {
         auto ds = dsv.As<v8::Object>();
@@ -1532,7 +1557,8 @@ static void FillRenderPipelineDescriptor(v8::Isolate* isolate, v8::Local<v8::Obj
     }
 
     // fragment
-    wgpu::FragmentState fragment = {};
+    // scratch.fragment を参照 (アドレスを desc.fragment に格納するため寿命を延ばす)。
+    wgpu::FragmentState& fragment = scratch.fragment;
     v8::Local<v8::Value> fv = Prop(isolate, d, "fragment");
     if (fv->IsObject()) {
         auto f = fv.As<v8::Object>();

package/templates/xbox/src/bindings/webgpu/WebGPUCommon.h

@@ -61,12 +61,15 @@ inline v8::Local<v8::ObjectTemplate> HandleTemplate(v8::Isolate* isolate)
 }
 
 // --- JS オブジェクト読み取りヘルパー ------------------------------------
+// プロパティ名はキャッシュ済み internalized string (v8util::PropName) を使う。
+// ここは全ディスクリプタ解析の合流点で毎フレーム数千回通るため、名前 v8::String の
+// 毎回生成 (ヒープ確保 + ハッシュ) を排除する効果が大きい。
 inline v8::Local<v8::Value> Prop(v8::Isolate* isolate, v8::Local<v8::Object> obj,
                                  const char* key)
 {
     v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
     v8::Local<v8::Value> v;
-    if (obj->Get(ctx, v8util::Str(isolate, key)).ToLocal(&v)) {
+    if (obj->Get(ctx, v8util::PropName(isolate, key)).ToLocal(&v)) {
         return v;
     }
     return v8::Undefined(isolate);

package/templates/xbox/src/bindings/webgpu/WebGPUEnums.h

@@ -17,22 +17,54 @@ inline wgpu::TextureFormat ToTextureFormat(std::string_view s)
     if (s == "bgra8unorm")            return F::BGRA8Unorm;
     if (s == "bgra8unorm-srgb")       return F::BGRA8UnormSrgb;
     if (s == "rgba8snorm")            return F::RGBA8Snorm;
+    if (s == "rgba8uint")             return F::RGBA8Uint;
+    if (s == "rgba8sint")             return F::RGBA8Sint;
     if (s == "r8unorm")               return F::R8Unorm;
+    if (s == "r8snorm")               return F::R8Snorm;
+    if (s == "r8uint")                return F::R8Uint;
+    if (s == "r8sint")                return F::R8Sint;
     if (s == "rg8unorm")              return F::RG8Unorm;
+    if (s == "rg8snorm")              return F::RG8Snorm;
+    if (s == "rg8uint")               return F::RG8Uint;
+    if (s == "rg8sint")               return F::RG8Sint;
+    if (s == "r16uint")               return F::R16Uint;
+    if (s == "r16sint")               return F::R16Sint;
     if (s == "r16float")              return F::R16Float;
+    if (s == "rg16uint")              return F::RG16Uint;
+    if (s == "rg16sint")              return F::RG16Sint;
     if (s == "rg16float")             return F::RG16Float;
+    if (s == "rgba16uint")            return F::RGBA16Uint;
+    if (s == "rgba16sint")            return F::RGBA16Sint;
     if (s == "rgba16float")           return F::RGBA16Float;
+    if (s == "r32uint")               return F::R32Uint;
+    if (s == "r32sint")               return F::R32Sint;
     if (s == "r32float")              return F::R32Float;
+    if (s == "rg32uint")              return F::RG32Uint;
+    if (s == "rg32sint")              return F::RG32Sint;
     if (s == "rg32float")             return F::RG32Float;
+    if (s == "rgba32uint")            return F::RGBA32Uint;
+    if (s == "rgba32sint")            return F::RGBA32Sint;
     if (s == "rgba32float")           return F::RGBA32Float;
+    if (s == "rgb10a2unorm")          return F::RGB10A2Unorm;
+    if (s == "rg11b10ufloat")         return F::RG11B10Ufloat;
     if (s == "depth16unorm")          return F::Depth16Unorm;
     if (s == "depth24plus")           return F::Depth24Plus;
     if (s == "depth24plus-stencil8")  return F::Depth24PlusStencil8;
     if (s == "depth32float")          return F::Depth32Float;
+    if (s == "depth32float-stencil8") return F::Depth32FloatStencil8;
     if (s == "stencil8")              return F::Stencil8;
     return F::RGBA8Unorm;
 }
 
+inline wgpu::StorageTextureAccess ToStorageTextureAccess(std::string_view s)
+{
+    using A = wgpu::StorageTextureAccess;
+    if (s == "write-only") return A::WriteOnly;
+    if (s == "read-only")  return A::ReadOnly;
+    if (s == "read-write") return A::ReadWrite;
+    return A::WriteOnly;
+}
+
 inline wgpu::VertexFormat ToVertexFormat(std::string_view s)
 {
     using V = wgpu::VertexFormat;

package/templates/xbox/src/gpu/DawnContext.cpp

@@ -1,22 +1,160 @@
 #include "DawnContext.h"
 
 #include <Windows.h>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
 #include <iostream>
+#include <string>
 
 namespace next2d {
 
 namespace {
 
+// GUI 実行では stderr が見えないため、GPU の致命的エラー/検証エラーを
+// next2d-error.log にも残す。描画が黒くなる/表示されない等の原因(検証エラー・
+// device lost・リソース枯渇)を掴む唯一の手段。氾濫防止に総数を制限する。
+void AppendGpuLog(const std::string& line)
+{
+    static int count = 0;
+    if (count >= 60) {
+        return;
+    }
+    ++count;
+    std::ofstream ofs("next2d-error.log", std::ios::app);
+    if (ofs) {
+        ofs << line << std::endl;
+    }
+}
+
 void HandleDeviceLost(const wgpu::Device&, wgpu::DeviceLostReason reason, wgpu::StringView message)
 {
-    std::cerr << "[Dawn] Device lost (" << static_cast<int>(reason) << "): "
-              << std::string(message.data, message.length) << std::endl;
+    const std::string line = "[Dawn] Device lost (" + std::to_string(static_cast<int>(reason))
+        + "): " + std::string(message.data, message.length);
+    std::cerr << line << std::endl;
+    AppendGpuLog(line);
 }
 
 void HandleUncapturedError(const wgpu::Device&, wgpu::ErrorType type, wgpu::StringView message)
 {
-    std::cerr << "[Dawn] Uncaptured error (" << static_cast<int>(type) << "): "
-              << std::string(message.data, message.length) << std::endl;
+    const std::string line = "[Dawn] Uncaptured error (" + std::to_string(static_cast<int>(type))
+        + "): " + std::string(message.data, message.length);
+    std::cerr << line << std::endl;
+    AppendGpuLog(line);
+}
+
+// --- GPU Blob キャッシュ (シェーダ/パイプラインのコンパイル結果) -------------
+// D3D12 の HLSL コンパイル (FXC) はパイプライン初回生成時に走り、起動直後や
+// 新しいエフェクト初出時のフレームヒッチの原因になる。Dawn の BlobCache を
+// %LOCALAPPDATA%\Next2D\gpucache に永続化し、2 回目以降の起動で再利用する
+// (V8 バイトコードキャッシュの GPU 版)。
+// 呼び出し規約 (dawn/native/BlobCache.cpp LoadInternal で検証済み):
+//   load は 2 段階 — まず value=nullptr でサイズ問い合わせ (戻り値 0 = miss)、
+//   次に確保済みバッファへの読み込み (戻り値がサイズと不一致なら miss 扱い)。
+// キーには Dawn がアダプタ/ドライバ情報を織り込むため、環境が変われば自然に
+// 別エントリになる。あらゆる失敗は 0 / 何もしない (graceful degrade)。
+
+uint64_t Fnv1a(const void* data, size_t size, uint64_t hash = 1469598103934665603ull)
+{
+    const auto* p = static_cast<const unsigned char*>(data);
+    for (size_t i = 0; i < size; ++i) {
+        hash ^= p[i];
+        hash *= 1099511628211ull;
+    }
+    return hash;
+}
+
+const std::filesystem::path& GpuCacheDir()
+{
+    static const std::filesystem::path dir = []() -> std::filesystem::path {
+        const char* base = std::getenv("LOCALAPPDATA");
+        if (!base || !*base) {
+            return {};
+        }
+        std::error_code ec;
+        std::filesystem::path d = std::filesystem::path(base) / "Next2D" / "gpucache";
+        std::filesystem::create_directories(d, ec);
+        if (ec) {
+            return {};
+        }
+        // ドライバ/Dawn 更新でキーが変わると旧 blob は孤児になる。
+        // 30 日アクセスの無い .blob を掃除する (load ヒット時に touch する LRU)。
+        const auto now = std::filesystem::file_time_type::clock::now();
+        std::error_code iter_ec;
+        for (const auto& entry : std::filesystem::directory_iterator(d, iter_ec)) {
+            std::error_code e2;
+            if (entry.path().extension() != ".blob") {
+                continue;
+            }
+            const auto t = std::filesystem::last_write_time(entry.path(), e2);
+            if (!e2 && now - t > std::chrono::hours(24 * 30)) {
+                std::filesystem::remove(entry.path(), e2);
+            }
+        }
+        return d;
+    }();
+    return dir;
+}
+
+std::filesystem::path GpuCacheFileFor(const void* key, size_t key_size)
+{
+    const std::filesystem::path& dir = GpuCacheDir();
+    if (dir.empty()) {
+        return {};
+    }
+    char buf[17] = {};
+    std::snprintf(buf, sizeof(buf), "%016llx",
+                  static_cast<unsigned long long>(Fnv1a(key, key_size)));
+    return dir / (std::string(buf) + ".blob");
+}
+
+size_t LoadGpuCacheData(const void* key, size_t key_size,
+                        void* value, size_t value_size, void*)
+{
+    const std::filesystem::path file = GpuCacheFileFor(key, key_size);
+    if (file.empty()) {
+        return 0;
+    }
+    std::error_code ec;
+    const auto size = std::filesystem::file_size(file, ec);
+    if (ec || size == 0) {
+        return 0;
+    }
+    if (value == nullptr) {
+        // 1 段階目: サイズ問い合わせ
+        return static_cast<size_t>(size);
+    }
+    if (value_size < size) {
+        return 0;
+    }
+    std::ifstream ifs(file, std::ios::binary);
+    if (!ifs || !ifs.read(static_cast<char*>(value), static_cast<std::streamsize>(size))) {
+        return 0;
+    }
+    // 使用時に touch して 30 日掃除を LRU として機能させる
+    std::filesystem::last_write_time(
+        file, std::filesystem::file_time_type::clock::now(), ec);
+    return static_cast<size_t>(size);
+}
+
+void StoreGpuCacheData(const void* key, size_t key_size,
+                       const void* value, size_t value_size, void*)
+{
+    if (!value || value_size == 0) {
+        return;
+    }
+    const std::filesystem::path file = GpuCacheFileFor(key, key_size);
+    if (file.empty()) {
+        return;
+    }
+    std::ofstream ofs(file, std::ios::binary | std::ios::trunc);
+    if (ofs) {
+        ofs.write(static_cast<const char*>(value),
+                  static_cast<std::streamsize>(value_size));
+    }
 }
 
 } // namespace
@@ -95,6 +233,28 @@ bool DawnContext::AcquireDevice()
     device_desc.SetDeviceLostCallback(wgpu::CallbackMode::AllowProcessEvents, HandleDeviceLost);
     device_desc.SetUncapturedErrorCallback(HandleUncapturedError);
 
+    // GPU Blob キャッシュを接続する (シェーダコンパイル結果の永続化)。
+    // 関数ポインタは Dawn が device 生成時に BlobCache へコピーするため、
+    // この記述子自体は RequestDevice 完了までの生存で足りる。
+    wgpu::DawnCacheDeviceDescriptor cache_desc = {};
+    cache_desc.loadDataFunction  = LoadGpuCacheData;
+    cache_desc.storeDataFunction = StoreGpuCacheData;
+    device_desc.nextInChain = &cache_desc;
+
+#ifdef NDEBUG
+    // Release では Dawn の API 検証 (skip_validation) と robustness (OOB クランプ) を
+    // 無効化する。両方とも全描画コマンドのエンコードで毎フレーム CPU を消費する
+    // 安全網で、検証済みタイトルの出荷ビルドでは Chrome も同様に外す定番最適化。
+    // Debug ビルドでは有効のままにして検証エラーを検出できるようにする
+    // (エラーは HandleUncapturedError -> next2d-error.log へ出る)。
+    // toggle 名は Dawn 本体 src/dawn/native/Toggles.cpp 定義 (いずれも ToggleStage::Device)。
+    static const char* kReleaseToggles[] = {"skip_validation", "disable_robustness"};
+    wgpu::DawnTogglesDescriptor device_toggles = {};
+    device_toggles.enabledToggles     = kReleaseToggles;
+    device_toggles.enabledToggleCount = 2;
+    cache_desc.nextInChain = &device_toggles;  // device -> cache -> toggles
+#endif
+
     wgpu::Future device_future = adapter_.RequestDevice(
         &device_desc,
         wgpu::CallbackMode::AllowProcessEvents,
@@ -137,11 +297,10 @@ void DawnContext::Configure(uint32_t width, uint32_t height)
     wgpu::SurfaceConfiguration config = {};
     config.device      = device_;
     config.format      = format_;
+    // RenderAttachment のみ。CopySrc を足すと swapchain の flip 提示最適化が無効化され
+    // 提示ごとにコピーが挟まって重くなるため、描画確認が済んだ今は付けない
+    // (以前は DebugProbeSurface の黒画面調査用に付けていた)。
     config.usage       = wgpu::TextureUsage::RenderAttachment;
-    if (can_copy_src_) {
-        // 黒画面デバッグ用の surface 読み戻し (DebugProbeSurface) を可能にする
-        config.usage |= wgpu::TextureUsage::CopySrc;
-    }
     config.width       = width_;
     config.height      = height_;
     config.presentMode = wgpu::PresentMode::Fifo;
@@ -231,17 +390,9 @@ void DawnContext::Present()
     // 取得なしで Present すると Dawn の検証エラーになる (描画しないフレームは提示しない)。
     if (surface_ && configured_ && frame_texture_acquired_) {
         ++present_count_;
-        if (present_count_ <= 3 || present_count_ == 60 || present_count_ % 300 == 0) {
-            DebugProbeSurface();
-        }
         surface_.Present();
     } else {
         ++present_skipped_;
-        if (present_skipped_ <= 3 || present_skipped_ % 300 == 0) {
-            std::cerr << "[GPU] present skipped #" << present_skipped_
-                      << " (configured=" << configured_
-                      << " acquired=" << frame_texture_acquired_ << ")" << std::endl;
-        }
     }
     frame_texture_acquired_ = false;
     current_texture_ = nullptr;