VR
│
├─ 1. フルダイブVR
│ │
│ ├─ 定義・目標
│ │ ├─ 人工世界内で行動と感覚の循環を成立
│ │ ├─ 現実の身体運動への依存を減らす
│ │ └─ 0/1ではなく段階的に実現
│ │
│ ├─ 必要な基本機能
│ │ ├─ ① 動作意図を取得する
│ │ ├─ ② アバター／仮想世界を動かす
│ │ ├─ ③ 感覚を身体へフィードバックする
│ │ └─ ④ 現実由来の不要な感覚を抑える
│ │
│ └─ 実現段階
│ ├─ 現在のVR
│ ├─ Motion-Less VR
│ ├─ ハーフ／クォータダイブ
│ └─ 完全フルダイブ
│
├─ 2. 入力技術 ── 人間 → VR
│ │
│ ├─ BMI / BCI
│ │ ├─ Brain-machine Interface
│ │ ├─ 脳波センサー
│ │ ├─ 脳波によるゲーム操作
│ │ ├─ 医療BMI
│ │ └─ Neurable
│ │
│ ├─ Motion-Less VR
│ │ └─ 動作意図の取得
│ │
│ └─ 従来方式
│ └─ フルボディトラッキング
│
├─ 3. 感覚出力 ── VR → 人間
│ │
│ ├─ 視覚
│ ├─ 聴覚
│ ├─ 触覚
│ │ ├─ テスラスーツ
│ │ └─ 「触原色」／舘研究室
│ ├─ 運動感覚
│ │ └─ Motion-Less VR
│ ├─ 味覚
│ │ ├─ VRの味覚
│ │ └─ VRで食べられる食べ物
│ └─ 前庭感覚・身体感覚
│
├─ 4. 仮想身体
│ │
│ ├─ アバター
│ ├─ VRM
│ ├─ VRMより高度なアバター
│ ├─ Live2D → 3DCG
│ ├─ AIによる3DCG化
│ └─ 身体図式
│
├─ 5. 仮想世界
│ │
│ ├─ Unity
│ ├─ 3DCG
│ ├─ AIによる自動生成・配置
│ ├─ Google Earth
│ │ ├─ 地球データ
│ │ └─ 地球規模の仮想世界
│ └─ AI
│ ├─ アセット生成
│ ├─ 自動読み込み
│ └─ 自動配置
│
├─ 6. フルダイブVRの用途
│ │
│ ├─ フルダイブMMO
│ ├─ ゲーム
│ ├─ Vtuber
│ │ └─ フルダイブMMO内でアイドル活動
│ ├─ アート
│ ├─ 教育
│ │ ├─ フルダイブ型授業
│ │ └─ AIとの語学学習
│ └─ オンラインコミュニケーション
│
├─ 7. 社会・安全
│ │
│ ├─ 法律
│ ├─ VR社会のルール
│ ├─ 長時間利用
│ └─ VR酔い
│
├─ 8. 研究機関・研究
│ │
│ ├─ 人工世界実装研究室（AWIL）
│ │ ├─ Motion-Less VR
│ │ ├─ 運動意図
│ │ ├─ 運動感覚
│ │ └─ VR酔い
│ │
│ ├─ 舘研究室
│ │ └─ 触覚・テレイグジスタンス
│ │
│ └─ フルダイブ型VR授業研究
│
├─ 9. 資料・論文・URL
│ │
│ ├─ AWIL
│ ├─ PROTRUDE 2021
│ ├─ KDDI Research
│ ├─ NHK BMI
│ ├─ UploadVR / Neurable
│ ├─ 4Gamer
│ └─ 論文
│
└─ 10. 遠未来アイデア【フルダイブと分離】
│
├─ 不老不死
├─ DNA情報
├─ 量子テレポート
├─ 空飛ぶ車
├─ 自動運転
└─ 生殖関連アイデア

「現実世界でテレポーテーション装置を作る方法」ですね。これは多くのSF作品に出てくる夢の技術ですが、科学的に見て現状どうなっているかを整理しますね。

✨ 1. 「テレポーテーション」の定義

• SF的な転送
  人や物体を一瞬で別の場所に移す（スタートレック的な転送装置）。
• 科学的なテレポーテーション
  現実に存在するのは「量子テレポーテーション」と呼ばれる技術で、物体そのものではなく**量子状態（情報）**を転送する。

🔬 2. 実現しているもの（量子テレポーテーション）

• 光子（光の粒）や電子の「量子状態」を離れた場所に転送する実験は、すでに成功している。
• 仕組みは「量子もつれ」と「古典通信」を組み合わせて、ある粒子の状態を遠くに複製する。
• 2017年には中国の研究チームが、地上と宇宙（約1,200km）で量子テレポーテーションを実験的に成功させている。

🏗 3. もし「現実のテレポート装置」を作るとしたら？

1. 量子レベルで情報をスキャン
   人間を構成する原子は約 10^28 個（100,000,000,000,000,000,000,000,000,000 個！）。
   これら全ての位置・運動・量子状態を測定する必要がある。
2. 情報を転送
   超高速の通信インフラ（現代のインターネットの何兆倍もの容量）が必要。
3. 受信側で再構築
   原子を一つずつ並べ直す「原子レベルの3Dプリンター」が必要。
4. 意識の連続性の問題
   元の肉体はどうなる？コピーなのか本人なのか？「哲学的ゾンビ問題」が出てくる。

⚠️ 4. 現実的な課題

• 技術的：原子スキャン技術も、再構築技術も未完成。
• 物理的：量子力学の「不確定性原理」により、全ての情報を同時に測ることは理論的に不可能。
• 哲学的：転送先に「コピー」ができるなら、元の意識は残るのか？自分は自分のままか？

✅ まとめ

• 現実的に作れるテレポート装置はまだ存在しません。
• ただし「量子テレポーテーション（情報の瞬間転送）」は実際に成功しており、将来の量子通信・量子インターネットの基盤になろうとしています。
• 人や物を転送するには、技術的・物理的・哲学的にまだ「不可能」に近い段階。

👉 質問ですが、あなたが知りたいのは：

1. 現実の科学でできる範囲（量子テレポーテーションの仕組みや応用）
2. SF的にどう作ればいいか（ゲームや物語用の設定）

どちらをメインに深掘りしましょうか？

あなた:

現実の科学でできる範囲

ChatGPT:

なるほど！「現実の科学でできる範囲」でのテレポーテーションについて、できること・できないことを整理しますね。

🧩 1. 実際に成功している「量子テレポーテーション」

• 対象：光子（光の粒）、電子、原子などの「量子状態」
• 仕組み：
  1. 送信側と受信側に「量子もつれ（エンタングルメント）」した粒子を用意
  2. 送信側で「転送したい粒子」と「自分の持つエンタングル粒子」を測定
  3. 測定結果を通常の通信（電話や光ファイバーなど）で受信側へ送る
  4. 受信側は、自分の粒子をその結果に基づいて操作すると、送信側と同じ量子状態が再現される
• ポイント：
  • 物体そのものは動いていない
  • 情報だけが移動している
  • 「コピー」ではなく「転送」になるのは、測定によって送信元の状態が消滅するから

📡 2. 実験の実績

• 1997年：オーストリアの研究者が初の量子テレポーテーション実験に成功
• 2004年：米国NISTが原子レベルでの転送に成功
• 2017年：中国の「墨子号」衛星を使い、地上と宇宙間で約1,200kmの量子テレポーテーションに成功
• 2020年代：光ファイバーや衛星通信でのテレポーテーション精度向上の研究が進行中

🔬 3. 応用の可能性

• 量子通信
  傍受が不可能な「量子暗号通信（QKD）」を強化できる
• 量子インターネット
  量子コンピュータ同士を安全に接続し、離れた場所でも量子計算を共有可能
• 未来的な転送
  分子レベルの構造やDNA情報を転送 → 医療や物質研究で応用できる可能性あり

🚫 4. 限界・できないこと

• 人間や物体の転送は不可能
  原子は約10^28個、人間の脳のシナプスは100兆以上。
  それらを「測定 → 転送 → 再構築」するのは理論的にも技術的にも非現実的。
• 不確定性原理
  量子状態を完全に測定することは不可能（同時に位置と運動量を知れない）。
• 速度制限
  量子もつれは瞬時に関連するが、実際の情報伝達には「古典通信」が必要 → 光速を超えられない。

✅ まとめ

現実の科学で可能な「テレポーテーション」は：

• 物体ではなく「量子状態（情報）」の転送
• 実用化の方向は「量子通信・量子インターネット」
• 人間や物体の転送は現時点では不可能

👉 実際にやってみたいのは：

1. 量子テレポーテーションの仕組みをもっと理解（数式・物理的説明）
2. 量子通信（量子インターネット）の実用化がどこまで来ているか
3. 実験的にできる範囲（簡単な光子のテレポーテーション実験など）

どれを深掘りしましょうか？

あなた:

実験的にできる範囲（簡単な光子のテレポーテーション実験など）

ChatGPT:

いいですね 👍
「実験的にできる範囲」での 光子の量子テレポーテーション実験 を、シンプルにイメージできる形でまとめます。

🧪 光子テレポーテーションの最小実験構成

1. 必要なもの

• 光子源
  レーザー光を使って「対生成」（非線形結晶で光を分裂させる）により「エンタングル光子対」を作る。
• ビームスプリッター（BS）・偏光板（PBS）
  光子の経路や偏光状態を調整する。
• 検出器（SPD: Single Photon Detector）
  単一光子をカウントするための高感度検出器。
• 古典通信チャンネル
  光ファイバーや電気信号で測定結果を相手に伝える。

2. 実験の流れ（シンプルな例）

1. エンタングル光子対の生成
   • 結晶にレーザーを当てると「光子 A」と「光子 B」が量子もつれた状態で飛び出す。
2. 転送したい光子（光子 C）の準備
   • 任意の偏光状態をもつ光子 C を用意する（これを「送る対象」とする）。
3. ベル測定（A と C を一緒に測る）
   • 光子 A（もつれペアの片方）と光子 C（送りたい状態）を一緒に干渉させ、特殊な測定を行う。
   • 測定によって光子 C の状態は壊れるが、その情報が「A と B の相関」として B に反映される。
4. 古典通信
   • 測定結果を光ファイバーや電線で相手に送る。
5. 受信側での再構成
   • 光子 B に対し、送られてきた情報に基づいた操作（偏光回転など）をすると、光子 C と同じ状態が B に復元される。

🎯 実験で確認できること

• 光子 B の偏光状態が、確率的に光子 C の状態と一致していること。
• この「一致率（忠実度）」を統計的に測定することで、テレポーテーション成功を確認できる。
• 実験室レベルでは 数メートル〜数十km の光ファイバーで実証済み。

🔧 実験の難しさ

• 単一光子を安定して扱うのは難易度が高い（レーザー＋非線形光学結晶＋超精密光学系が必要）。
• 検出効率は100%ではなく、データは確率的になる。
• 実験キットは大学や研究所レベルで数千万円規模。

🌱 身近に体験できる方法

• 教育用量子光学キット
  • Thorlabs などの企業が「量子光学教育キット」を販売（偏光のもつれ光子を扱える）。
• シミュレーション
  • IBM Quantum Experience や QuTiP (Pythonライブラリ) を使えば、量子テレポーテーションのアルゴリズムをシミュレート可能。
  • 実際の量子ビット上で「状態を転送する」動きを試せる。

✅ まとめ

• 現実に「簡単にできる」範囲では、量子計算機シミュレーションでの光子テレポーテーションがおすすめ。
• 研究室レベルなら 光学系を組んでエンタングル光子対を作り、偏光状態の転送を確認するのが典型的な実験。
• 規模的には「個人で部屋に転送装置を置く」ことは不可能だが、「小規模な量子実験をシミュレーションする」ことは誰でも可能。

👉 興味ありますか？

• 実際に Python + Qiskit（IBM Quantum）で量子テレポーテーションをシミュレーションするコード例 を紹介しましょうか？

ChatGPT:

いいですね、かなりSF的でワクワクするテーマです！
ただ「VRナノマシンをPCに接続する」というのは、現実的にはまだ存在していない技術で、あくまで未来の研究領域・サイエンスフィクションの範囲です。そこで、現実的に近い技術や、もし実現するならどうなるかを整理してみます👇

🔬 現実に近い技術

• BCI（Brain-Computer Interface / 脳-コンピュータ・インターフェース）
  • 例: Neuralink, Emotiv, OpenBCI
    脳波を読み取り、PCやVRに信号を送る仕組み。現状は「考えるだけでマウスを動かす」「VRの簡単な操作をする」段階。
• 神経刺激装置
  電気刺激を使って筋肉や神経に信号を送る。リハビリや義手の制御に使われている。
• ナノマシン的な医療研究
  体内に入れて血流や細胞をモニタリングするマイクロマシンは研究中。
  ただし「PCに直接つなぐ」というのはまだ不可能。

💡 SF的な「VRナノマシン接続」のイメージ

• インターフェース方法
  体内に入ったナノマシンが神経や脳細胞と接続 → Bluetoothや量子通信的な仕組みでPCとリンク。
• VRへの応用
  • 視覚・聴覚 → 脳の対応する領域に直接映像や音を入力。
  • 触覚・痛覚 → ナノマシンが神経信号を人工的に発生。
  • 運動制御 → 脳からの運動信号を読み取り、VRキャラクターに反映。
• 完全フルダイブVR
  PCやクラウドに接続されたナノマシンが「五感＋身体の運動」を全て制御し、現実の体を休眠状態にしたままVR世界を体験。

⚠️ 現実的な課題

• 安全性（体内に入れる以上、免疫反応や副作用のリスク）
• 倫理（意識の制御・記憶の改ざんなどの悪用リスク）
• 技術的限界（神経ネットワークをナノマシンが完全に把握するのは現時点では不可能）

✅ まとめ

現時点で「VRナノマシンをPCに接続する」ことは不可能ですが、
現実に近いのは「脳波計（BCI）＋VR」 です。
未来的には、ナノマシンが「フルダイブVR」を実現する鍵になる、と想定されています。

👉 ご質問ですが、あなたが考えているのは：

1. 現実に近い仕組み（BCIをPCに繋いでVRに使う方法）を知りたい
2. SF的にどうやってVRナノマシンを接続するか設定を作りたい（小説・ゲーム用）

どちらのイメージに近いですか？

あなた:

現実に近い仕組み（BCIをPCに繋いでVRに使う方法

ChatGPT:

なるほど！「現実に近い仕組み」として、BCI（Brain-Computer Interface）をPCに繋いでVRに活用する方法 を整理してみますね。これは「フルダイブVR」の入り口とも言える分野です。

🧠 1. BCIをPCに接続する仕組み

現実に使える代表的なBCIデバイスには次のようなものがあります：

• Emotiv Epoc / Insight
  市販されているEEG（脳波）デバイス。USBドングルやBluetoothでPCに接続可能。
• OpenBCI
  オープンソースのBCIプラットフォーム。脳波をPCに取り込み、PythonやUnityで処理できる。
• NextMind（Metaに買収済）
  視覚に関連する脳活動を読み取り、PC入力に使えたデバイス（現在は販売停止）。

👉 接続は主に USB / Bluetooth → PC → SDK / API という流れです。

🎮 2. VRへの応用例

入力（脳→VR）

• 意図の検出：
  たとえば「右手を動かそう」と考えると、それに対応する脳波パターンを検出し、VR内のキャラが手を動かす。
• 選択操作：
  メニューの選択を「集中」「リラックス」などの脳波状態で行う。

出力（VR→脳）

• これはまだ発展途上。
  • 触覚グローブ＋電気刺激 で「触った感覚」を返す
  • 脳に直接フィードバックを送る実験は研究段階

🔧 3. 開発の流れ（現実的な実装）

1. BCIデバイスを準備
   例：OpenBCIの「Ultracortex Mark IV」＋「Ganglionボード」
2. PCに接続
   • BluetoothまたはUSBドングル
   • OpenBCI GUIで脳波を可視化できる
3. データを解析
   • Python（MNE, BrainFlowなど）で脳波データを処理
   • 「特定の脳波パターン → コマンド」にマッピング
4. VRと連携
   • UnityやUnreal EngineにBCI SDKを組み込み
   • キャラクター操作やUI選択に反映

⚡ 4. 実際の限界と可能性

• 現状できること
  • シンプルなコマンド入力（ジャンプ、選択、移動開始など）
  • 「集中」「リラックス」の状態を使ったUI制御
• まだ難しいこと
  • 五感すべてを直接書き換える
  • 高精度で複雑な動きを完全に思考だけで操作する

✅ 現実的には「脳波でVR内の簡単な動作を操作できる」レベルですが、BCI＋VR は確実に発展していて、数年以内に「ハンドトラッキング＋脳波コマンド」くらいまでは実用化される見込みです。

👉 もしあなたがやりたいのは：

1. 実際にBCI＋VRを試してみたい → 「どのデバイスを買えばいいか？」をまとめます
2. 開発に組み込みたい → 「Unity/Unrealとの接続コード例」を提示します

どちらに興味がありますか？

あなた:

Unity/Unrialとの接続コード

ChatGPT:

思考時間: 18s

了解！BCI→PC→VR を“今すぐ動かせる”形で、Pythonブリッジ（EEG取得）→ UDP(JSON) 配信 → Unity / Unreal で受信という最小構成のサンプルを用意しました。
実機（OpenBCI/Emotiv）がなくてもダミー信号で動作確認できます。実機がある場合はコメントを外すだけでOK。

① Python：BCIブリッジ（EEG→UDP配信）

• 役割：EEGを読み取り、{"t":timestamp, "focus":0.0-1.0, "channels":[…]} のJSONを UDP で 127.0.0.1:9001 へ送信
• 実機がない場合はランダム波形で動作（USE_DUMMY=True）
• 実機（例：BrainFlow/OpenBCI）に切替えるときはコメントを外して設定

# bci_bridge_udp.py
import json, socket, time, random, math
from collections import deque

USE_DUMMY = True        # 実機があれば False にして下の BrainFlow 部分を有効化
TARGET_HOST = "127.0.0.1"
TARGET_PORT = 9001
FS = 250                # サンプルレート想定
NCH = 8                 # チャンネル数

# --- 実機（BrainFlow/OpenBCI）の例 ---
# from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
# BoardShim.enable_dev_board_logger()
# params = BrainFlowInputParams()
# params.serial_port = "/dev/ttyUSB0"  # Windowsなら "COM3" など
# board = BoardShim(BoardIds.CYTON_BOARD.value, params)
# board.prepare_session()
# board.start_stream()

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
buf = deque(maxlen=FS)  # 1秒分の簡易バッファ（フォーカス計算用ダミー）

def compute_focus(sample):
    """
    簡易フォーカス指標（デモ用）:
    サンプルの絶対値の逆数を用いた擬似的な安定度スコア 0..1
    実機ではバンドパワーなどに置換推奨
    """
    buf.append(sum(abs(x) for x in sample) / max(1, len(sample)))
    avg = sum(buf) / max(1, len(buf))
    focus = max(0.0, min(1.0, 1.0 / (1.0 + avg)))  # 値が小さいほど集中度高い扱い
    return focus

try:
    print(f"Streaming UDP to {TARGET_HOST}:{TARGET_PORT} (Ctrl+C to stop)")
    phase = 0.0
    while True:
        if USE_DUMMY:
            # ダミー：α帯域っぽいゆっくり波 + ノイズ
            phase += 2 * math.pi * 10 / FS  # 10 Hz 風
            sample = [0.5*math.sin(phase + i*0.1) + 0.1*random.uniform(-1,1) for i in range(NCH)]
            time.sleep(1.0/FS)
        else:
            # 実機から最新サンプル取得（例）
            # data = board.get_current_board_data(1)  # shape: (n_channels, n_samples)
            # sample = [float(data[ch][0]) for ch in range(NCH)]
            # time.sleep(1.0/FS)
            sample = [0.0]*NCH  # 実機利用時に上を有効化

        payload = {
            "t": time.time(),
            "focus": compute_focus(sample),
            "channels": sample
        }
        sock.sendto(json.dumps(payload).encode("utf-8"), (TARGET_HOST, TARGET_PORT))
except KeyboardInterrupt:
    pass
finally:
    # if not USE_DUMMY:
    #     board.stop_stream()
    #     board.release_session()
    sock.close()

② Unity（C#）：UDP受信 → ゲーム操作

• 役割：UDPで受け取った focus を使って一定以上でジャンプ、またはUIを点滅など
• Assets/Scripts/BCIUdpReceiver.cs として保存
• シーンに空のGameObject「BCIReceiver」を作成し、このスクリプトをアタッチ
• Player には CharacterController か Rigidbody + AddForce 等でジャンプ実装を用意

// Assets/Scripts/BCIUdpReceiver.cs
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;

[Serializable]
public class BciPacket {
    public double t;
    public float focus;
    public float[] channels;
}

public class BCIUdpReceiver : MonoBehaviour
{
    [Header("UDP Settings")]
    public int listenPort = 9001;

    [Header("Gameplay")]
    [Range(0f, 1f)] public float focusThreshold = 0.8f;
    public float minInterval = 0.5f; // コマンド間隔(秒)
    public GameObject player;

    UdpClient _udp;
    Thread _thread;
    volatile bool _running;
    volatile float _latestFocus;
    float _lastActionTime;

    void Start()
    {
        _udp = new UdpClient(listenPort);
        _running = true;
        _thread = new Thread(ReceiveLoop);
        _thread.IsBackground = true;
        _thread.Start();
        Debug.Log($"BCI UDP listening on {listenPort}");
    }

    void ReceiveLoop()
    {
        IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0);
        while (_running)
        {
            try
            {
                byte[] data = _udp.Receive(ref ep);
                string json = Encoding.UTF8.GetString(data);
                var pkt = JsonUtility.FromJson<BciPacket>(json);
                _latestFocus = pkt.focus;
            }
            catch (Exception) { /* ignore */ }
        }
    }

    void Update()
    {
        // デモ：フォーカスが閾値を超えたらジャンプ入力
        if (Time.time - _lastActionTime > minInterval && _latestFocus >= focusThreshold)
        {
            _lastActionTime = Time.time;
            TryJump();
        }
    }

    void TryJump()
    {
        if (!player) { Debug.Log("Player not assigned."); return; }

        // キャラクター制御の例：Rigidbody に上方向インパルス
        var rb = player.GetComponent<Rigidbody>();
        if (rb != null)
        {
            rb.AddForce(Vector3.up * 5f, ForceMode.VelocityChange);
            return;
        }

        // CharacterController の例：単純に上方向へ瞬間移動（実プロジェクトは自前のジャンプ処理へ接続）
        var cc = player.GetComponent<CharacterController>();
        if (cc != null)
        {
            cc.Move(Vector3.up * 0.5f);
        }
    }

    void OnApplicationQuit()
    {
        _running = false;
        try { _udp?.Close(); } catch { }
        try { _thread?.Join(100); } catch { }
    }
}

ヒント：UIにフォーカスメーターを出したい場合は Image.fillAmount = _latestFocus; を Update() に追加するだけでOK。

③ Unreal Engine 5（C++）：UDP受信 → ブループリントに通知

• 役割：UDP(JSON)を受信し、Focus値をイベントでブループリントに流す
• 手順
  1. C++プロジェクトで ActorComponent を追加（名前：BCIUdpReceiverComponent）
  2. 下記コードで置き換え
  3. レベル内のアクター（キャラ等）にアタッチ
  4. ブループリント側で OnFocusUpdated を Bind → Focus >= 0.8 でジャンプなど

// BCIUdpReceiverComponent.h
#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "BCIUdpReceiverComponent.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FFocusUpdated, float, Focus);

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class YOURPROJECT_API UBCIUdpReceiverComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="BCI")
    int32 ListenPort = 9001;

    UPROPERTY(BlueprintAssignable, Category="BCI")
    FFocusUpdated OnFocusUpdated;

protected:
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

private:
    FSocket* Socket = nullptr;
    FThreadSafeBool bRunning = false;
    FRunnableThread* Thread = nullptr;

    class FBCIWorker* Worker = nullptr;
    void HandleFocusOnGameThread(float Focus);
};

// BCIUdpReceiverComponent.cpp
#include "BCIUdpReceiverComponent.h"
#include "Sockets.h"
#include "SocketSubsystem.h"
#include "HAL/Runnable.h"
#include "HAL/RunnableThread.h"
#include "Common/UdpSocketBuilder.h"
#include "IPAddress.h"
#include "Misc/ScopeLock.h"
#include "Serialization/JsonReader.h"
#include "Serialization/JsonSerializer.h"

class FBCIWorker : public FRunnable
{
public:
    FBCIWorker(FSocket* InSocket, TFunction<void(float)> InOnFocus)
        : Socket(InSocket), OnFocus(MoveTemp(InOnFocus)) {}

    virtual uint32 Run() override
    {
        uint8 Buffer[2048];
        while (bRun)
        {
            if (!Socket) { FPlatformProcess::Sleep(0.005f); continue; }

            int32 BytesRead = 0;
            if (Socket->Recv(Buffer, sizeof(Buffer), BytesRead, ESocketReceiveFlags::None) && BytesRead > 0)
            {
                FString Json = FString(UTF8_TO_TCHAR(reinterpret_cast<const char*>(Buffer)));
                TSharedPtr<FJsonObject> Obj;
                auto Reader = TJsonReaderFactory<>::Create(Json);
                if (FJsonSerializer::Deserialize(Reader, Obj) && Obj.IsValid())
                {
                    double FocusVal = 0.0;
                    if (Obj->TryGetNumberField(TEXT("focus"), FocusVal))
                    {
                        OnFocus(static_cast<float>(FocusVal));
                    }
                }
            }
            else
            {
                FPlatformProcess::Sleep(0.002f);
            }
        }
        return 0;
    }

    void StopWork() { bRun = false; }

private:
    FSocket* Socket = nullptr;
    TFunction<void(float)> OnFocus;
    FThreadSafeBool bRun = true;
};

void UBCIUdpReceiverComponent::BeginPlay()
{
    Super::BeginPlay();

    // UDP ソケット作成
    FUdpSocketBuilder Builder(TEXT("BCI_UDP_Receiver"));
    Socket = FUdpSocketBuilder(TEXT("BCI_UDP_Receiver"))
        .AsNonBlocking()
        .AsReusable()
        .BoundToPort(ListenPort)
        .WithReceiveBufferSize(2 * 1024 * 1024);

    if (!Socket)
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to create UDP socket on port %d"), ListenPort);
        return;
    }

    bRunning = true;

    Worker = new FBCIWorker(Socket, [this](float Focus){
        // ソケットスレッド → ゲームスレッドへディスパッチ
        AsyncTask(ENamedThreads::GameThread, [this, Focus](){ HandleFocusOnGameThread(Focus); });
    });

    Thread = FRunnableThread::Create(Worker, TEXT("BCI_UDP_Worker"));
    UE_LOG(LogTemp, Log, TEXT("BCI UDP listening on %d"), ListenPort);
}

void UBCIUdpReceiverComponent::HandleFocusOnGameThread(float Focus)
{
    OnFocusUpdated.Broadcast(Focus);
}

void UBCIUdpReceiverComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    if (Worker) { Worker->StopWork(); }
    if (Thread) { Thread->Kill(true); delete Thread; Thread = nullptr; }
    if (Worker) { delete Worker; Worker = nullptr; }
    if (Socket) { Socket->Close(); ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(Socket); Socket = nullptr; }

    Super::EndPlay(EndPlayReason);
}

ブループリント接続例

• レベル内のキャラクターBPに BCIUdpReceiverComponent を追加
• Event Graph で OnFocusUpdated をバインド
• Focus >= 0.8 なら Jump or 任意のアクションを呼ぶ

動作確認手順（共通）

1. Python: python bci_bridge_udp.py を実行（「Streaming UDP…」が出ればOK）
2. Unity または Unreal を起動してプレイ
3. focusThreshold を 0.6～0.85 の範囲で調整（ダミー信号なら0.75前後で反応）

実機に繋げるときのヒント

• OpenBCI / BrainFlow
  • Python側で BrainFlow の BoardShim を有効化し、serial_port を実機のポートへ
  • バンドパワー（α/βなど）→ 正規化 → focus へ変換
• Emotiv
  • Emotiv SDK から Python で値取得 → 同じUDP形式で送信
• LSL(LabStreamingLayer)を使いたい場合
  • Python: LSLでEEG/Markerを送出
  • Unity: LSL4Unity
  • Unreal: LSLプラグイン
    （今回は依存ゼロのUDPにしていますが、研究用途ではLSLが定番です）

必要なら、

• Unity の UIメーター（フォーカス可視化）
• より堅牢なスレッドキューや再接続
• Unreal の純BP版（C++なし）
  もすぐ追加できます。どっちを先に強化します？