@next2d/builder 0.1.7 → 0.1.10

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

@@ -15,6 +15,7 @@
 #include <v8.h>
 
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
 
 #include <memory>
 #include <string>
@@ -27,13 +28,8 @@ struct Holder {
     T handle;
 };
 
-template <typename T>
-void ReleaseHolder(const v8::WeakCallbackInfo<Holder<T>>& info)
-{
-    delete info.GetParameter();
-}
-
 // wgpu ハンドル T を、指定 ObjectTemplate から生成したオブジェクトにラップする。
+// GC 時の解放は AttachWeak (第一パスで Global を Reset する規約に準拠) に委ねる。
 template <typename T>
 v8::Local<v8::Object> Wrap(v8::Isolate* isolate,
                            v8::Local<v8::ObjectTemplate> tmpl,
@@ -43,8 +39,7 @@ v8::Local<v8::Object> Wrap(v8::Isolate* isolate,
     v8::Local<v8::Object> obj = tmpl->NewInstance(ctx).ToLocalChecked();
     auto* holder = new Holder<T>{std::move(handle)};
     obj->SetInternalField(0, v8::External::New(isolate, holder));
-    auto* global = new v8::Global<v8::Object>(isolate, obj);
-    global->SetWeak(holder, ReleaseHolder<T>, v8::WeakCallbackType::kParameter);
+    v8util::AttachWeak(isolate, obj, holder);
     return obj;
 }
 
@@ -66,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,23 +1,160 @@
 #include "DawnContext.h"
 
 #include <Windows.h>
-#include <dawn/native/DawnNative.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
@@ -96,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,
@@ -114,12 +273,13 @@ bool DawnContext::AcquireDevice()
         return false;
     }
 
-    // surface の優先フォーマットを取得
+    // surface の優先フォーマットと CopySrc 可否 (デバッグ読み戻し用) を取得
     wgpu::SurfaceCapabilities caps = {};
     surface_.GetCapabilities(adapter_, &caps);
     if (caps.formatCount > 0) {
         format_ = caps.formats[0];
     }
+    can_copy_src_ = (caps.usages & wgpu::TextureUsage::CopySrc) == wgpu::TextureUsage::CopySrc;
 
     Configure(width_, height_);
     return true;
@@ -137,6 +297,9 @@ 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;
     config.width       = width_;
     config.height      = height_;
@@ -144,20 +307,95 @@ void DawnContext::Configure(uint32_t width, uint32_t height)
     config.alphaMode   = wgpu::CompositeAlphaMode::Opaque;
 
     surface_.Configure(&config);
+    configured_ = true;
 }
 
 wgpu::Texture DawnContext::GetCurrentTexture()
 {
+    if (!configured_) {
+        return nullptr;
+    }
     wgpu::SurfaceTexture surface_texture = {};
     surface_.GetCurrentTexture(&surface_texture);
+    frame_texture_acquired_ = true;
+    current_texture_ = surface_texture.texture;
     return surface_texture.texture;
 }
 
+// 提示直前の surface 中央行を読み戻し、非黒ピクセル数をログする (黒画面調査用)。
+// CI では目視できないため、これが「画面に何が出ているか」の唯一の証拠になる。
+void DawnContext::DebugProbeSurface()
+{
+    if (!can_copy_src_ || !current_texture_ || width_ == 0) {
+        std::cerr << "[GPU] surface probe unavailable (CopySrc="
+                  << (can_copy_src_ ? "yes" : "no") << ")" << std::endl;
+        return;
+    }
+
+    const uint32_t row_bytes = width_ * 4;
+    wgpu::BufferDescriptor buf_desc = {};
+    buf_desc.size  = (row_bytes + 3) & ~3u;
+    buf_desc.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
+    wgpu::Buffer buffer = device_.CreateBuffer(&buf_desc);
+
+    wgpu::TexelCopyTextureInfo src = {};
+    src.texture = current_texture_;
+    src.origin  = { 0, height_ / 2, 0 };
+
+    wgpu::TexelCopyBufferInfo dst = {};
+    dst.buffer = buffer;
+    dst.layout.offset = 0;
+    dst.layout.bytesPerRow = wgpu::kCopyStrideUndefined;   // 1 行コピーでは不要
+
+    wgpu::Extent3D extent = { width_, 1, 1 };
+
+    wgpu::CommandEncoder encoder = device_.CreateCommandEncoder();
+    encoder.CopyTextureToBuffer(&src, &dst, &extent);
+    wgpu::CommandBuffer commands = encoder.Finish();
+    device_.GetQueue().Submit(1, &commands);
+
+    bool done = false;
+    wgpu::Future future = buffer.MapAsync(wgpu::MapMode::Read, 0, buf_desc.size,
+        wgpu::CallbackMode::AllowProcessEvents,
+        [&done](wgpu::MapAsyncStatus, wgpu::StringView) { done = true; });
+    // GPU 完了待ちは TimedWaitAny で行う (ProcessEvents の空スピンでは
+    // GPU がフレーム描画中のとき完了前にループ上限へ達する)
+    instance_.WaitAny(future, 2'000'000'000);   // 2s
+    if (!done) {
+        std::cerr << "[GPU] surface probe: map timeout" << std::endl;
+        return;
+    }
+
+    const auto* px = static_cast<const uint8_t*>(buffer.GetConstMappedRange(0, buf_desc.size));
+    uint32_t non_black = 0;
+    for (uint32_t x = 0; px && x < width_; ++x) {
+        const uint8_t* p = px + static_cast<size_t>(x) * 4;
+        if (p[0] || p[1] || p[2]) {
+            ++non_black;
+        }
+    }
+    std::cerr << "[GPU] surface probe (present #" << present_count_
+              << "): non-black " << non_black << "/" << width_ << " px";
+    if (px && width_ > 1) {
+        const uint8_t* c = px + static_cast<size_t>(width_ / 2) * 4;
+        std::cerr << ", center=(" << +c[0] << "," << +c[1] << "," << +c[2] << "," << +c[3] << ")";
+    }
+    std::cerr << std::endl;
+    buffer.Unmap();
+}
+
 void DawnContext::Present()
 {
-    if (surface_) {
+    // 提示するのは「未構成でない」かつ「今フレーム GetCurrentTexture 済み」のときのみ。
+    // 取得なしで Present すると Dawn の検証エラーになる (描画しないフレームは提示しない)。
+    if (surface_ && configured_ && frame_texture_acquired_) {
+        ++present_count_;
         surface_.Present();
+    } else {
+        ++present_skipped_;
     }
+    frame_texture_acquired_ = false;
+    current_texture_ = nullptr;
 }
 
 void DawnContext::Tick()

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

@@ -36,6 +36,9 @@ public:
     // 提示する。
     void Present();
 
+    // 提示直前の surface 中央行を読み戻して非黒ピクセル数をログする (黒画面調査用)。
+    void DebugProbeSurface();
+
     // Dawn の非同期イベント(コールバック)を進める。毎フレーム呼ぶ。
     void Tick();
 
@@ -59,6 +62,21 @@ private:
     HWND     hwnd_   = nullptr;
     uint32_t width_  = 0;
     uint32_t height_ = 0;
+
+    // surface が Configure 済みか。未構成のまま Present すると Dawn の
+    // 検証エラーが毎フレーム出るため、Present/GetCurrentTexture をゲートする。
+    bool     configured_ = false;
+
+    // 今フレーム GetCurrentTexture が呼ばれたか。呼ばれていないフレームで
+    // Present すると Dawn の検証エラーになるため、Present をゲートする
+    // (アプリが描画しないフレームは提示しない)。
+    bool     frame_texture_acquired_ = false;
+
+    // デバッグ用: surface の CopySrc 可否 / 今フレームのテクスチャ / 提示統計
+    bool          can_copy_src_ = false;
+    wgpu::Texture current_texture_ = nullptr;
+    uint64_t      present_count_ = 0;
+    uint64_t      present_skipped_ = 0;
 };
 
 } // namespace next2d